using AcDream.Core.Chat;
using AcDream.Core.Social;
using AcDream.Runtime.Gameplay;

namespace AcDream.Runtime.Tests.Gameplay;

public sealed class RuntimeCommunicationStateTests
{
    [Fact]
    public void OwnsOneExactCommunicationGraphAndPublishesCommittedEntries()
    {
        using var state = new RuntimeCommunicationState();
        var observer = new RecordingObserver();
        using IDisposable subscription = state.Events.Subscribe(observer);

        state.Chat.OnTellReceived("Bestie", "hello", 0x50000001u);

        RuntimeCommunicationEvent delta = Assert.Single(observer.Events);
        Assert.Equal(1UL, delta.Sequence);
        Assert.Equal(state.Chat.Revision, delta.Entry.Revision);
        Assert.Equal(1, state.View.Count);
        Assert.Equal(state.Chat.Revision, state.View.Revision);
        Assert.Equal(1UL, state.LastSequence);
        Assert.Equal(0, state.PendingDispatchCount);
        Assert.False(state.IsDispatching);
        Assert.Equal("Bestie", state.CommandTargets.LastIncomingTellSender);
        Assert.Equal("hello", delta.Entry.Text);
    }

    [Fact]
    public void ReentrantAppendPreservesSequenceForEveryObserver()
    {
        using var state = new RuntimeCommunicationState();
        var reentrant = new ReentrantObserver(state.Chat);
        var trailing = new RecordingObserver();
        using IDisposable first = state.Events.Subscribe(reentrant);
        using IDisposable second = state.Events.Subscribe(trailing);

        state.Chat.OnSystemMessage("first", 0u);

        Assert.Equal([1UL, 2UL], reentrant.Sequences);
        Assert.Equal(
            [1UL, 2UL],
            trailing.Events.Select(item => item.Sequence).ToArray());
        Assert.Equal(["first", "second"], trailing.Events
            .Select(item => item.Entry.Text)
            .ToArray());
        Assert.Equal(0, state.PendingDispatchCount);
        Assert.False(state.IsDispatching);
    }

    [Fact]
    public void ObserverFailureDoesNotStarveLaterObserverOrOwner()
    {
        using var state = new RuntimeCommunicationState();
        var recording = new RecordingObserver();
        using IDisposable throwing =
            state.Events.Subscribe(new ThrowingObserver());
        using IDisposable trailing = state.Events.Subscribe(recording);

        state.Chat.OnSystemMessage("still committed", 0u);

        Assert.Equal(1, state.Chat.Count);
        Assert.Single(recording.Events);
        Assert.Equal(1, state.DispatchFailureCount);
        Assert.IsType<InvalidOperationException>(state.LastDispatchFailure);
    }

    [Fact]
    public void SessionResetsClearScopedStateWithoutClearingTranscript()
    {
        using var state = new RuntimeCommunicationState();
        state.Chat.OnTellReceived("Bestie", "hello", 0x50000001u);
        state.Chat.OnSelfSent(ChatKind.Tell, "outgoing", "Caith");
        state.TurbineChat.OnChannelsReceived(
            1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u, 9u, 10u);
        state.Friends.Apply(new FriendsUpdate(
            FriendsUpdateType.Full,
            [new FriendEntry(1u, "Friend", true, false, [], [])]));
        state.Squelch.Replace(new SquelchDatabase(
            new Dictionary<string, uint> { ["account"] = 1u },
            new Dictionary<uint, SquelchInfo>(),
            new SquelchInfo(string.Empty, false, new HashSet<uint>())));

        state.ResetCommandTargets();
        state.ResetChatIdentity();
        state.ResetNegotiatedChannels();
        state.ResetFriends();
        state.ResetSquelch();

        Assert.Equal(2, state.Chat.Count);
        Assert.Null(state.CommandTargets.LastIncomingTellSender);
        Assert.Null(state.CommandTargets.LastOutgoingTellTarget);
        Assert.False(state.TurbineChat.Enabled);
        Assert.Empty(state.Friends.Snapshot());
        Assert.Empty(state.Squelch.Snapshot().Accounts);
    }

    [Fact]
    public void DisposeDetachesStreamAndAllBorrowedState()
    {
        var state = new RuntimeCommunicationState();
        var observer = new RecordingObserver();
        IDisposable subscription = state.Events.Subscribe(observer);

        state.Dispose();
        state.Dispose();
        state.Chat.OnSystemMessage("after dispose", 0u);

        Assert.True(state.IsDisposed);
        Assert.Equal(0, state.SubscriberCount);
        Assert.Empty(observer.Events);
        Assert.Throws<ObjectDisposedException>(
            () => state.Events.Subscribe(new RecordingObserver()));
        subscription.Dispose();
    }

    [Fact]
    public void IndependentRuntimeInstancesNeverShareState()
    {
        using var first = new RuntimeCommunicationState();
        using var second = new RuntimeCommunicationState();

        first.Chat.OnTellReceived("OnlyFirst", "hello", 0x50000001u);

        Assert.Equal(1, first.View.Count);
        Assert.Equal(0, second.View.Count);
        Assert.Equal("OnlyFirst", first.CommandTargets.LastIncomingTellSender);
        Assert.Null(second.CommandTargets.LastIncomingTellSender);
    }

    private sealed class RecordingObserver : IRuntimeCommunicationObserver
    {
        public List<RuntimeCommunicationEvent> Events { get; } = [];

        public void OnChat(in RuntimeCommunicationEvent delta) =>
            Events.Add(delta);
    }

    private sealed class ReentrantObserver(ChatLog chat)
        : IRuntimeCommunicationObserver
    {
        public List<ulong> Sequences { get; } = [];

        public void OnChat(in RuntimeCommunicationEvent delta)
        {
            Sequences.Add(delta.Sequence);
            if (delta.Sequence == 1UL)
                chat.OnSystemMessage("second", 1u);
        }
    }

    private sealed class ThrowingObserver : IRuntimeCommunicationObserver
    {
        public void OnChat(in RuntimeCommunicationEvent delta) =>
            throw new InvalidOperationException("observer");
    }
}