// Copyright 2025 The NATS Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Mirrors server/jetstream_test.go in the NATS server Go source.
// Tests that can be exercised via the NATS JetStream wire API are implemented;
// tests that require direct Go server internals or a JetStream cluster are deferred.

using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using NATS.Client.Core;
using Shouldly;

namespace ZB.MOM.NatsNet.Server.IntegrationTests.JetStream;

/// <summary>
/// Integration tests for JetStream core operations.
/// Mirrors server/jetstream_test.go.
/// Tests requiring direct server internals or a cluster remain deferred.
/// </summary>
[Trait("Category", "Integration")]
public sealed class JetStreamTests : IAsyncLifetime
{
    private NatsConnection? _nats;
    private Exception? _initFailure;

    public async Task InitializeAsync()
    {
        try
        {
            _nats = new NatsConnection(new NatsOpts { Url = "nats://localhost:4222" });
            await _nats.ConnectAsync();
        }
        catch (Exception ex)
        {
            _initFailure = ex;
        }
    }

    public async Task DisposeAsync()
    {
        if (_nats is not null)
            await _nats.DisposeAsync();
    }

    private bool ServerUnavailable() => _initFailure != null;

    // -----------------------------------------------------------------------
    // Helpers
    // -----------------------------------------------------------------------

    private static byte[] Json(object obj) =>
        JsonSerializer.SerializeToUtf8Bytes(obj);

    private async Task<JsonObject?> JsApiAsync(string subject, byte[]? payload = null)
    {
        var resp = await _nats!.RequestAsync<byte[], byte[]>(subject, payload);
        if (resp.Data is null) return null;
        return JsonNode.Parse(resp.Data) as JsonObject;
    }

    private async Task<string> CreateStreamAsync(
        string? name = null,
        string[]? subjects = null,
        string storage = "memory",
        string? retention = null,
        int maxMsgs = 0,
        long maxBytes = 0)
    {
        name ??= $"S_{Guid.NewGuid():N}"[..16];
        subjects ??= new[] { name.ToLower() + ".>" };

        var cfg = new JsonObject
        {
            ["name"]    = name,
            ["storage"] = storage,
        };
        if (subjects.Length > 0)
            cfg["subjects"] = new JsonArray(subjects.Select(s => (JsonNode?)JsonValue.Create(s)).ToArray());
        if (retention != null)
            cfg["retention"] = retention;
        if (maxMsgs > 0)
            cfg["max_msgs"] = maxMsgs;
        if (maxBytes > 0)
            cfg["max_bytes"] = maxBytes;

        var resp = await JsApiAsync($"$JS.API.STREAM.CREATE.{name}", Encoding.UTF8.GetBytes(cfg.ToJsonString()));
        resp.ShouldNotBeNull();
        resp!["error"].ShouldBeNull($"Stream create failed: {resp["error"]}");
        return name;
    }

    private async Task DeleteStreamAsync(string name)
    {
        await JsApiAsync($"$JS.API.STREAM.DELETE.{name}");
    }

    private async Task<string> CreateConsumerAsync(
        string stream,
        string? durable = null,
        string? filterSubject = null,
        string? deliverPolicy = null,
        string? ackPolicy = null)
    {
        durable ??= $"C_{Guid.NewGuid():N}"[..12];
        var cfg = new JsonObject { ["durable_name"] = durable };
        if (filterSubject != null) cfg["filter_subject"] = filterSubject;
        if (deliverPolicy != null) cfg["deliver_policy"] = deliverPolicy;
        if (ackPolicy != null) cfg["ack_policy"] = ackPolicy;

        var resp = await JsApiAsync($"$JS.API.CONSUMER.CREATE.{stream}.{durable}",
            Encoding.UTF8.GetBytes(new JsonObject { ["stream_name"] = stream, ["config"] = cfg }.ToJsonString()));
        resp.ShouldNotBeNull();
        resp!["error"].ShouldBeNull($"Consumer create failed: {resp["error"]}");
        return durable;
    }

    private async Task PublishAsync(string subject, string data = "test", string? msgId = null)
    {
        if (msgId != null)
        {
            var headers = new NatsHeaders { ["Nats-Msg-Id"] = msgId };
            await _nats!.PublishAsync(subject, Encoding.UTF8.GetBytes(data), headers: headers);
        }
        else
        {
            await _nats!.PublishAsync(subject, Encoding.UTF8.GetBytes(data));
        }
    }

    private async Task<JsonObject?> StreamInfoAsync(string name)
    {
        return await JsApiAsync($"$JS.API.STREAM.INFO.{name}");
    }

    // -----------------------------------------------------------------------
    // TestJetStreamAddStreamOverlapWithJSAPISubjects
    // Verifies that streams cannot be created with subjects overlapping $JS.API.>
    // -----------------------------------------------------------------------

    [Fact]
    public async Task AddStreamOverlapWithJSAPISubjects_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        // Attempting to add a stream capturing $JS.API.> should produce an error
        var badCfg = new JsonObject
        {
            ["name"]     = "OVERLAP_BAD",
            ["storage"]  = "memory",
            ["subjects"] = new JsonArray(JsonValue.Create("$JS.API.>")),
        };
        var resp = await JsApiAsync("$JS.API.STREAM.CREATE.OVERLAP_BAD",
            Encoding.UTF8.GetBytes(badCfg.ToJsonString()));
        resp.ShouldNotBeNull();
        resp!["error"].ShouldNotBeNull("Expected error for $JS.API.> subject overlap");

        // $JS.EVENT.> should be allowed
        var goodName = $"OVERLAP_GOOD_{Guid.NewGuid():N}"[..20];
        var goodCfg = new JsonObject
        {
            ["name"]     = goodName,
            ["storage"]  = "memory",
            ["subjects"] = new JsonArray(JsonValue.Create("$JS.EVENT.>")),
        };
        var goodResp = await JsApiAsync($"$JS.API.STREAM.CREATE.{goodName}",
            Encoding.UTF8.GetBytes(goodCfg.ToJsonString()));
        goodResp.ShouldNotBeNull();
        goodResp!["error"].ShouldBeNull($"Expected success for $JS.EVENT.>, got: {goodResp["error"]}");

        await DeleteStreamAsync(goodName);
    }

    // -----------------------------------------------------------------------
    // TestJetStreamPublishDeDupe
    // Verifies publish deduplication via Nats-Msg-Id header.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task PublishDeDupe_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        var streamName = $"DEDUPE_{Guid.NewGuid():N}"[..16];
        var subject = $"foo.{streamName}";
        await CreateStreamAsync(streamName, new[] { $"foo.{streamName}" }, storage: "file");

        try
        {
            // Publish 4 unique messages with IDs
            async Task<JsonObject?> SendMsg(string id, string data)
            {
                var headers = new NatsHeaders { ["Nats-Msg-Id"] = id };
                var resp = await _nats!.RequestAsync<byte[], byte[]>(
                    subject, Encoding.UTF8.GetBytes(data), headers: headers);
                return resp.Data != null ? JsonNode.Parse(resp.Data) as JsonObject : null;
            }

            var r1 = await SendMsg("AA", "Hello DeDupe!");
            r1.ShouldNotBeNull();
            r1!["error"].ShouldBeNull();

            var r2 = await SendMsg("BB", "Hello DeDupe!");
            r2!["error"].ShouldBeNull();

            var r3 = await SendMsg("CC", "Hello DeDupe!");
            r3!["error"].ShouldBeNull();

            var r4 = await SendMsg("ZZ", "Hello DeDupe!");
            r4!["error"].ShouldBeNull();

            // Stream should have 4 messages
            var info = await StreamInfoAsync(streamName);
            var msgs = info?["state"]?["messages"]?.GetValue<long>() ?? 0;
            msgs.ShouldBe(4L);

            // Re-send same IDs — should be duplicates
            var rDup1 = await SendMsg("AA", "Hello DeDupe!");
            rDup1!["duplicate"]?.GetValue<bool>().ShouldBe(true);

            var rDup2 = await SendMsg("BB", "Hello DeDupe!");
            rDup2!["duplicate"]?.GetValue<bool>().ShouldBe(true);

            // Still 4 messages
            info = await StreamInfoAsync(streamName);
            msgs = info?["state"]?["messages"]?.GetValue<long>() ?? 0;
            msgs.ShouldBe(4L);
        }
        finally
        {
            await DeleteStreamAsync(streamName);
        }
    }

    // -----------------------------------------------------------------------
    // TestJetStreamUsageNoReservation
    // Verifies streams created without MaxBytes have zero reserved storage.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task UsageNoReservation_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        var fileStream = $"USAGE_FILE_{Guid.NewGuid():N}"[..20];
        var memStream  = $"USAGE_MEM_{Guid.NewGuid():N}"[..20];

        await CreateStreamAsync(fileStream, storage: "file");
        await CreateStreamAsync(memStream, storage: "memory");

        try
        {
            // Account info should show streams were created
            var info = await JsApiAsync("$JS.API.INFO");
            info.ShouldNotBeNull();
            var streams = info?["streams"]?.GetValue<int>() ?? 0;
            streams.ShouldBeGreaterThanOrEqualTo(2);
        }
        finally
        {
            await DeleteStreamAsync(fileStream);
            await DeleteStreamAsync(memStream);
        }
    }

    // -----------------------------------------------------------------------
    // TestJetStreamUsageReservationNegativeMaxBytes
    // Verifies streams with MaxBytes=-1 behave like no reservation.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task UsageReservationNegativeMaxBytes_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        var streamName = $"RESERV_{Guid.NewGuid():N}"[..16];
        var cfg = new JsonObject
        {
            ["name"]      = streamName,
            ["storage"]   = "memory",
            ["max_bytes"] = 1024,
        };
        var createResp = await JsApiAsync($"$JS.API.STREAM.CREATE.{streamName}",
            Encoding.UTF8.GetBytes(cfg.ToJsonString()));
        createResp!["error"].ShouldBeNull();

        try
        {
            // Update to -1 MaxBytes (meaning no limit)
            cfg["max_bytes"] = -1;
            var updateResp = await JsApiAsync($"$JS.API.STREAM.UPDATE.{streamName}",
                Encoding.UTF8.GetBytes(cfg.ToJsonString()));
            updateResp.ShouldNotBeNull();
            // -1 should be accepted and treated as unlimited
            updateResp!["error"].ShouldBeNull($"Unexpected error: {updateResp["error"]}");
        }
        finally
        {
            await DeleteStreamAsync(streamName);
        }
    }

    // -----------------------------------------------------------------------
    // TestJetStreamSnapshotsAPI — deferred: requires server file store internals
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires direct server snapshot/restore API access")]
    public void SnapshotsAPI_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamInterestRetentionStreamWithFilteredConsumers
    // Verifies interest retention policy with filtered consumers via wire API.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task InterestRetentionStreamWithFilteredConsumers_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        var streamName = $"INTEREST_{Guid.NewGuid():N}"[..16];
        var cfg = new JsonObject
        {
            ["name"]      = streamName,
            ["storage"]   = "memory",
            ["subjects"]  = new JsonArray(JsonValue.Create(streamName + ".*")),
            ["retention"] = "interest",
        };
        var createResp = await JsApiAsync($"$JS.API.STREAM.CREATE.{streamName}",
            Encoding.UTF8.GetBytes(cfg.ToJsonString()));
        createResp!["error"].ShouldBeNull($"Stream create error: {createResp["error"]}");

        try
        {
            // Without consumers, messages should not accumulate
            for (int i = 0; i < 5; i++)
                await _nats!.PublishAsync($"{streamName}.foo", Encoding.UTF8.GetBytes("msg"));

            await Task.Delay(50);
            var info = await StreamInfoAsync(streamName);
            // With interest retention and no consumers, messages may be discarded immediately
            var msgs = info?["state"]?["messages"]?.GetValue<long>() ?? 0;
            msgs.ShouldBeLessThanOrEqualTo(5L);
        }
        finally
        {
            await DeleteStreamAsync(streamName);
        }
    }

    // -----------------------------------------------------------------------
    // TestJetStreamSimpleFileRecovery — deferred: requires server restart
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires server restart to test file recovery")]
    public void SimpleFileRecovery_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamPushConsumerFlowControl — deferred: requires push consumer with heartbeats
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires push consumer flow control infrastructure")]
    public void PushConsumerFlowControl_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamFilteredStreamNames
    // Verifies $JS.API.STREAM.NAMES with subject filter.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task FilteredStreamNames_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        var prefix = $"FSN_{Guid.NewGuid():N}"[..8];
        var s1 = $"{prefix}_S1"; var s2 = $"{prefix}_S2"; var s3 = $"{prefix}_S3";

        await CreateStreamAsync(s1, new[] { $"{prefix}.foo" });
        await CreateStreamAsync(s2, new[] { $"{prefix}.bar" });
        await CreateStreamAsync(s3, new[] { $"{prefix}.baz" });

        try
        {
            // Query names filtered by subject
            var req = new JsonObject { ["subject"] = $"{prefix}.foo" };
            var resp = await JsApiAsync("$JS.API.STREAM.NAMES",
                Encoding.UTF8.GetBytes(req.ToJsonString()));
            resp.ShouldNotBeNull();
            resp!["error"].ShouldBeNull();

            var streams = resp["streams"]?.AsArray();
            streams.ShouldNotBeNull();
            streams!.Select(n => n!.GetValue<string>()).ShouldContain(s1);
        }
        finally
        {
            await DeleteStreamAsync(s1);
            await DeleteStreamAsync(s2);
            await DeleteStreamAsync(s3);
        }
    }

    // -----------------------------------------------------------------------
    // TestJetStreamUpdateStream
    // Verifies stream update via $JS.API.STREAM.UPDATE.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task UpdateStream_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        var streamName = $"UPDATE_{Guid.NewGuid():N}"[..16];
        await CreateStreamAsync(streamName, new[] { streamName + ".foo" });

        try
        {
            // Update max_msgs limit
            var updateCfg = new JsonObject
            {
                ["name"]     = streamName,
                ["storage"]  = "memory",
                ["subjects"] = new JsonArray(JsonValue.Create(streamName + ".foo")),
                ["max_msgs"] = 50,
            };
            var updateResp = await JsApiAsync($"$JS.API.STREAM.UPDATE.{streamName}",
                Encoding.UTF8.GetBytes(updateCfg.ToJsonString()));
            updateResp.ShouldNotBeNull();
            updateResp!["error"].ShouldBeNull($"Update error: {updateResp["error"]}");

            var maxMsgs = updateResp["config"]?["max_msgs"]?.GetValue<long>() ?? 0;
            maxMsgs.ShouldBe(50L);

            // Change name should fail
            var badCfg = new JsonObject
            {
                ["name"]    = "WRONG_NAME",
                ["storage"] = "memory",
            };
            var badResp = await JsApiAsync($"$JS.API.STREAM.UPDATE.{streamName}",
                Encoding.UTF8.GetBytes(badCfg.ToJsonString()));
            badResp.ShouldNotBeNull();
            badResp!["error"].ShouldNotBeNull("Expected error when updating with wrong name");
        }
        finally
        {
            await DeleteStreamAsync(streamName);
        }
    }

    // -----------------------------------------------------------------------
    // TestJetStreamDeleteMsg
    // Verifies message deletion via $JS.API.MSG.DELETE.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task DeleteMsg_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        var streamName = $"DELMSG_{Guid.NewGuid():N}"[..16];
        var subject    = streamName + ".foo";
        await CreateStreamAsync(streamName, new[] { subject }, storage: "memory");

        try
        {
            // Publish 10 messages
            for (int i = 0; i < 10; i++)
            {
                var ackResp = await _nats!.RequestAsync<byte[], byte[]>(
                    subject, Encoding.UTF8.GetBytes($"msg{i}"));
                ackResp.Data.ShouldNotBeNull();
            }

            var infoBefore = await StreamInfoAsync(streamName);
            infoBefore?["state"]?["messages"]?.GetValue<long>().ShouldBe(10L);

            // Delete message at sequence 5
            var delReq  = new JsonObject { ["seq"] = 5 };
            var delResp = await JsApiAsync($"$JS.API.MSG.DELETE.{streamName}",
                Encoding.UTF8.GetBytes(delReq.ToJsonString()));
            delResp.ShouldNotBeNull();
            delResp!["error"].ShouldBeNull($"Delete error: {delResp["error"]}");
            delResp["success"]?.GetValue<bool>().ShouldBe(true);

            // Should now have 9 messages
            var infoAfter = await StreamInfoAsync(streamName);
            infoAfter?["state"]?["messages"]?.GetValue<long>().ShouldBe(9L);

            // Delete first
            var delFirst = new JsonObject { ["seq"] = 1 };
            await JsApiAsync($"$JS.API.MSG.DELETE.{streamName}",
                Encoding.UTF8.GetBytes(delFirst.ToJsonString()));

            // Delete last
            var delLast = new JsonObject { ["seq"] = 10 };
            await JsApiAsync($"$JS.API.MSG.DELETE.{streamName}",
                Encoding.UTF8.GetBytes(delLast.ToJsonString()));

            var infoFinal = await StreamInfoAsync(streamName);
            infoFinal?["state"]?["messages"]?.GetValue<long>().ShouldBe(7L);
        }
        finally
        {
            await DeleteStreamAsync(streamName);
        }
    }

    // -----------------------------------------------------------------------
    // TestJetStreamRedeliveryAfterServerRestart — deferred: requires restart
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires server restart to test redelivery recovery")]
    public void DeliveryAfterServerRestart_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamConfigReloadWithGlobalAccount — deferred: requires config reload
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires server config reload infrastructure")]
    public void ConfigReloadWithGlobalAccount_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamGetLastMsgBySubject
    // Verifies direct-get last message by subject via $JS.API.DIRECT.GET.LAST.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task GetLastMsgBySubject_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        var streamName = $"LASTMSG_{Guid.NewGuid():N}"[..16];
        var subject    = streamName + ".test";
        await CreateStreamAsync(streamName, new[] { streamName + ".*" }, storage: "memory");

        try
        {
            // Publish several messages
            for (int i = 0; i < 5; i++)
                await _nats!.PublishAsync(subject, Encoding.UTF8.GetBytes($"msg{i}"));

            await Task.Delay(50);

            // Get last message by subject via STREAM.MSG.GET
            var getReq = new JsonObject { ["last_by_subj"] = subject };
            var getResp = await JsApiAsync($"$JS.API.STREAM.MSG.GET.{streamName}",
                Encoding.UTF8.GetBytes(getReq.ToJsonString()));
            getResp.ShouldNotBeNull();
            getResp!["error"].ShouldBeNull($"Get last msg error: {getResp["error"]}");
            getResp["message"].ShouldNotBeNull();
        }
        finally
        {
            await DeleteStreamAsync(streamName);
        }
    }

    // -----------------------------------------------------------------------
    // TestJetStreamGetLastMsgBySubjectAfterUpdate — deferred: requires direct server mset API
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires direct server stream state access after update")]
    public void GetLastMsgBySubjectAfterUpdate_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamLastSequenceBySubject
    // Verifies last sequence tracking per subject.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task LastSequenceBySubject_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        var streamName = $"LASTSEQ_{Guid.NewGuid():N}"[..16];
        await CreateStreamAsync(streamName, new[] { streamName + ".*" }, storage: "memory");

        try
        {
            await _nats!.PublishAsync(streamName + ".a", Encoding.UTF8.GetBytes("first"));
            await _nats.PublishAsync(streamName + ".a", Encoding.UTF8.GetBytes("second"));
            await _nats.PublishAsync(streamName + ".b", Encoding.UTF8.GetBytes("third"));

            await Task.Delay(50);

            var getReq = new JsonObject { ["last_by_subj"] = streamName + ".a" };
            var getResp = await JsApiAsync($"$JS.API.STREAM.MSG.GET.{streamName}",
                Encoding.UTF8.GetBytes(getReq.ToJsonString()));
            getResp.ShouldNotBeNull();
            getResp!["error"].ShouldBeNull();

            // The last message for subject ".a" should be seq 2
            var seq = getResp["message"]?["seq"]?.GetValue<long>() ?? 0;
            seq.ShouldBe(2L);
        }
        finally
        {
            await DeleteStreamAsync(streamName);
        }
    }

    // -----------------------------------------------------------------------
    // TestJetStreamLastSequenceBySubjectWithSubject — deferred: needs mset internals
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires direct server stream internals for subject sequence tracking")]
    public void LastSequenceBySubjectWithSubject_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamMirrorBasics — deferred: requires mirror stream infrastructure
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires mirror stream infrastructure and server restart")]
    public void MirrorBasics_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamSourceBasics — deferred: requires sourcing infrastructure
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires stream sourcing infrastructure")]
    public void SourceBasics_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamSourceWorkingQueueWithLimit — deferred: requires sourcing + clustering
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires stream sourcing with work queue and limit")]
    public void SourceWorkingQueueWithLimit_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamStreamSourceFromKV — deferred: requires KV + sourcing
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires KV store and stream sourcing infrastructure")]
    public void StreamSourceFromKV_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamInputTransform — deferred: requires stream transform config
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires stream subject transform infrastructure")]
    public void InputTransform_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamServerEncryption — deferred: requires server encryption config
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires server encryption configuration")]
    public void ServerEncryption_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamEphemeralPullConsumers
    // Verifies ephemeral pull consumer creation and fetch via wire API.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task EphemeralPullConsumers_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        var streamName = $"EPHEM_{Guid.NewGuid():N}"[..14];
        var subject    = streamName + ".data";
        await CreateStreamAsync(streamName, new[] { subject }, storage: "memory");

        try
        {
            // Publish a message
            await _nats!.RequestAsync<byte[], byte[]>(subject, Encoding.UTF8.GetBytes("hello"));

            // Create an ephemeral pull consumer (no durable name)
            var consCfg = new JsonObject
            {
                ["stream_name"] = streamName,
                ["config"]      = new JsonObject
                {
                    ["filter_subject"] = subject,
                    ["ack_policy"]     = "explicit",
                },
            };
            var consResp = await JsApiAsync($"$JS.API.CONSUMER.CREATE.{streamName}",
                Encoding.UTF8.GetBytes(consCfg.ToJsonString()));
            consResp.ShouldNotBeNull();
            consResp!["error"].ShouldBeNull($"Consumer create error: {consResp["error"]}");

            var consName = consResp["name"]?.GetValue<string>() ?? consResp["config"]?["name"]?.GetValue<string>();
            consName.ShouldNotBeNullOrEmpty();

            // Fetch the message
            var nextReq = new JsonObject { ["batch"] = 1, ["expires"] = "2s" };
            var inbox   = "_INBOX." + Guid.NewGuid().ToString("N");

            var sub = await _nats.SubscribeCoreAsync<byte[]>(inbox);
            await _nats.PublishAsync(
                $"$JS.API.CONSUMER.MSG.NEXT.{streamName}.{consName}",
                Encoding.UTF8.GetBytes(nextReq.ToJsonString()),
                replyTo: inbox);

            var received = false;
            using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(3)))
            {
                await foreach (var msg in sub.Msgs.ReadAllAsync(cts.Token))
                {
                    if (msg.Data is { Length: > 0 })
                    {
                        received = true;
                        break;
                    }
                }
            }
            received.ShouldBeTrue("Expected to receive a message from the ephemeral pull consumer");
        }
        finally
        {
            await DeleteStreamAsync(streamName);
        }
    }

    // -----------------------------------------------------------------------
    // TestJetStreamRemoveExternalSource — deferred: requires external source infra
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires external stream source infrastructure")]
    public void RemoveExternalSource_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamInvalidRestoreRequests
    // Verifies that restore API returns errors for invalid requests.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task InvalidRestoreRequests_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        // Restore of a non-existent/invalid snapshot should return an error
        var restoreReq = new JsonObject
        {
            ["config"] = new JsonObject { ["name"] = "NONEXISTENT_RESTORE" },
        };
        var resp = await JsApiAsync("$JS.API.STREAM.RESTORE",
            Encoding.UTF8.GetBytes(restoreReq.ToJsonString()));
        resp.ShouldNotBeNull();
        // Should get an error response for invalid restore
        resp!["error"].ShouldNotBeNull("Expected error for invalid restore request");
    }

    // -----------------------------------------------------------------------
    // TestJetStreamProperErrorDueToOverlapSubjects
    // Verifies overlapping subject errors from stream creation.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task ProperErrorDueToOverlapSubjects_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        var prefix = $"OVL_{Guid.NewGuid():N}"[..8];
        var s1 = $"{prefix}_A";
        await CreateStreamAsync(s1, new[] { $"{prefix}.>" });

        try
        {
            // Create a second stream with overlapping subject should fail
            var s2 = $"{prefix}_B";
            var badCfg = new JsonObject
            {
                ["name"]     = s2,
                ["storage"]  = "memory",
                ["subjects"] = new JsonArray(JsonValue.Create($"{prefix}.foo")),
            };
            var resp = await JsApiAsync($"$JS.API.STREAM.CREATE.{s2}",
                Encoding.UTF8.GetBytes(badCfg.ToJsonString()));
            resp.ShouldNotBeNull();
            resp!["error"].ShouldNotBeNull("Expected overlap error for duplicate subjects");
        }
        finally
        {
            await DeleteStreamAsync(s1);
        }
    }

    // -----------------------------------------------------------------------
    // TestJetStreamMsgBlkFailOnKernelFault — deferred: requires file store fault injection
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires file store fault injection at kernel level")]
    public void MsgBlkFailOnKernelFault_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamPartialPurgeWithAckPending
    // Verifies purge with filter subject.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task PartialPurgeWithAckPending_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        var streamName = $"PPURGE_{Guid.NewGuid():N}"[..15];
        await CreateStreamAsync(streamName, new[] { streamName + ".*" }, storage: "memory");

        try
        {
            // Publish messages to two subjects
            for (int i = 0; i < 5; i++)
                await _nats!.PublishAsync(streamName + ".a", Encoding.UTF8.GetBytes($"a{i}"));
            for (int i = 0; i < 5; i++)
                await _nats!.PublishAsync(streamName + ".b", Encoding.UTF8.GetBytes($"b{i}"));

            await Task.Delay(50);

            var infoBefore = await StreamInfoAsync(streamName);
            infoBefore?["state"]?["messages"]?.GetValue<long>().ShouldBe(10L);

            // Purge only subject .a
            var purgeReq = new JsonObject { ["filter"] = streamName + ".a" };
            var purgeResp = await JsApiAsync($"$JS.API.STREAM.PURGE.{streamName}",
                Encoding.UTF8.GetBytes(purgeReq.ToJsonString()));
            purgeResp.ShouldNotBeNull();
            purgeResp!["error"].ShouldBeNull($"Purge error: {purgeResp["error"]}");

            var infoAfter = await StreamInfoAsync(streamName);
            infoAfter?["state"]?["messages"]?.GetValue<long>().ShouldBe(5L);
        }
        finally
        {
            await DeleteStreamAsync(streamName);
        }
    }

    // -----------------------------------------------------------------------
    // TestJetStreamPurgeWithRedeliveredPending — deferred: requires consumer ack state
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires consumer ack pending state and internal stream access")]
    public void PurgeWithRedeliveredPending_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamLastSequenceBySubjectConcurrent — deferred: requires concurrent internal access
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires concurrent internal server state access")]
    public void LastSequenceBySubjectConcurrent_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamLimitsToInterestPolicy — deferred: requires direct stream retention mutation
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires direct server API to change retention policy")]
    public void LimitsToInterestPolicy_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamLimitsToInterestPolicyWhileAcking — deferred: same as above
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires direct server API to change retention policy while acking")]
    public void LimitsToInterestPolicyWhileAcking_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamSyncInterval — deferred: requires file store sync internals
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires file store sync interval configuration")]
    public void SyncInterval_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamSubjectFilteredPurgeClearsPendingAcks
    // Verifies subject-filtered purge correctly counts purged messages.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task SubjectFilteredPurgeClearsPendingAcks_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        var streamName = $"SFPURGE_{Guid.NewGuid():N}"[..15];
        await CreateStreamAsync(streamName, new[] { streamName + ".*" }, storage: "memory");

        try
        {
            for (int i = 0; i < 3; i++)
                await _nats!.PublishAsync(streamName + ".x", Encoding.UTF8.GetBytes($"x{i}"));
            for (int i = 0; i < 3; i++)
                await _nats!.PublishAsync(streamName + ".y", Encoding.UTF8.GetBytes($"y{i}"));

            await Task.Delay(50);

            // Purge with filter
            var purgeReq  = new JsonObject { ["filter"] = streamName + ".x" };
            var purgeResp = await JsApiAsync($"$JS.API.STREAM.PURGE.{streamName}",
                Encoding.UTF8.GetBytes(purgeReq.ToJsonString()));
            purgeResp!["error"].ShouldBeNull();

            var purged = purgeResp["purged"]?.GetValue<long>() ?? 0;
            purged.ShouldBe(3L);
        }
        finally
        {
            await DeleteStreamAsync(streamName);
        }
    }

    // -----------------------------------------------------------------------
    // TestJetStreamAckAllWithLargeFirstSequenceAndNoAckFloor — deferred: needs consumer internals
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires consumer ack floor internal state")]
    public void AckAllWithLargeFirstSequenceAndNoAckFloor_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAckAllWithLargeFirstSequenceAndNoAckFloorWithInterestPolicy — deferred
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires consumer ack floor with interest policy")]
    public void AckAllWithLargeFirstSequenceAndNoAckFloorWithInterestPolicy_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAuditStreams
    // Verifies stream list and info are accessible via wire API.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task AuditStreams_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        var streamName = $"AUDIT_{Guid.NewGuid():N}"[..14];
        await CreateStreamAsync(streamName, new[] { streamName + ".>" });

        try
        {
            // List streams
            var listResp = await JsApiAsync("$JS.API.STREAM.LIST");
            listResp.ShouldNotBeNull();
            listResp!["error"].ShouldBeNull();
            var total = listResp["total"]?.GetValue<int>() ?? 0;
            total.ShouldBeGreaterThanOrEqualTo(1);

            // Stream info
            var info = await StreamInfoAsync(streamName);
            info.ShouldNotBeNull();
            info!["error"].ShouldBeNull();
            info["config"]?["name"]?.GetValue<string>().ShouldBe(streamName);
        }
        finally
        {
            await DeleteStreamAsync(streamName);
        }
    }

    // -----------------------------------------------------------------------
    // TestJetStreamSourceRemovalAndReAdd — deferred: requires sourcing infrastructure
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires stream source removal and re-add lifecycle")]
    public void SourceRemovalAndReAdd_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamRateLimitHighStreamIngestDefaults — deferred: requires rate limit internals
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires server rate limit internal state")]
    public void RateLimitHighStreamIngestDefaults_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamSourcingClipStartSeq — deferred: requires sourcing with clip
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires stream source clip start sequence")]
    public void SourcingClipStartSeq_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamMirroringClipStartSeq — deferred: requires mirror clip
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires stream mirror clip start sequence")]
    public void MirroringClipStartSeq_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamMessageTTLWhenSourcing — deferred: requires message TTL + sourcing
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires message TTL infrastructure with sourcing")]
    public void MessageTTLWhenSourcing_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamMessageTTLWhenMirroring — deferred: requires message TTL + mirroring
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires message TTL infrastructure with mirroring")]
    public void MessageTTLWhenMirroring_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamInterestMaxDeliveryReached — deferred: requires consumer max delivery + interest
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires consumer max delivery with interest retention")]
    public void InterestMaxDeliveryReached_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamWQMaxDeliveryReached — deferred: requires work queue + max delivery
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires work queue consumer max delivery tracking")]
    public void WQMaxDeliveryReached_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamMaxDeliveryRedeliveredReporting — deferred: requires consumer redelivery state
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires consumer redelivery count reporting internals")]
    public void MaxDeliveryRedeliveredReporting_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamUpgradeConsumerVersioning — deferred: requires consumer version upgrade
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires consumer versioning upgrade infrastructure")]
    public void UpgradeConsumerVersioning_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamTHWExpireTasksRace — deferred: requires timer heap internals
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires timer heap worker expire task race detection")]
    public void THWExpireTasksRace_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamStreamRetentionUpdatesConsumers — deferred: requires direct retention update
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires direct server stream retention update")]
    public void StreamRetentionUpdatesConsumers_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamMaxMsgsPerSubjectAndDeliverLastPerSubject
    // Verifies MaxMsgsPerSubject with DeliverLastPerSubject consumer.
    // -----------------------------------------------------------------------

    [Fact]
    public async Task MaxMsgsPerSubjectAndDeliverLastPerSubject_ShouldSucceed()
    {
        if (ServerUnavailable()) return;

        var streamName = $"MXPERSUB_{Guid.NewGuid():N}"[..16];
        var cfg = new JsonObject
        {
            ["name"]                = streamName,
            ["storage"]             = "memory",
            ["subjects"]            = new JsonArray(JsonValue.Create(streamName + ".*")),
            ["max_msgs_per_subject"] = 1,
        };
        var createResp = await JsApiAsync($"$JS.API.STREAM.CREATE.{streamName}",
            Encoding.UTF8.GetBytes(cfg.ToJsonString()));
        createResp!["error"].ShouldBeNull($"Create error: {createResp["error"]}");

        try
        {
            // Publish 3 messages to same subject — only 1 should remain per limit
            for (int i = 0; i < 3; i++)
                await _nats!.PublishAsync(streamName + ".a", Encoding.UTF8.GetBytes($"msg{i}"));
            for (int i = 0; i < 3; i++)
                await _nats!.PublishAsync(streamName + ".b", Encoding.UTF8.GetBytes($"msg{i}"));

            await Task.Delay(100);

            var info = await StreamInfoAsync(streamName);
            var msgs = info?["state"]?["messages"]?.GetValue<long>() ?? 0;
            msgs.ShouldBe(2L, "Each subject should retain only 1 message");
        }
        finally
        {
            await DeleteStreamAsync(streamName);
        }
    }

    // -----------------------------------------------------------------------
    // TestJetStreamAllowMsgCounter — deferred: requires allow_msg_counter stream config
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires allow_msg_counter stream configuration")]
    public void AllowMsgCounter_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAllowMsgCounterMaxPayloadAndSize — deferred: same
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires allow_msg_counter with payload size checks")]
    public void AllowMsgCounterMaxPayloadAndSize_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAllowMsgCounterMirror — deferred: same + mirror
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires allow_msg_counter with mirror stream")]
    public void AllowMsgCounterMirror_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAllowMsgCounterSourceAggregates — deferred: same + source
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires allow_msg_counter with source aggregation")]
    public void AllowMsgCounterSourceAggregates_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAllowMsgCounterSourceVerbatim — deferred: same + verbatim
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires allow_msg_counter with verbatim source")]
    public void AllowMsgCounterSourceVerbatim_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAllowMsgCounterSourceStartingAboveZero — deferred
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires allow_msg_counter with non-zero start sequence")]
    public void AllowMsgCounterSourceStartingAboveZero_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamPromoteMirrorDeletingOrigin — deferred: requires mirror promotion
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires mirror stream promotion by deleting origin")]
    public void PromoteMirrorDeletingOrigin_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamPromoteMirrorUpdatingOrigin — deferred: same
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires mirror stream promotion by updating origin")]
    public void PromoteMirrorUpdatingOrigin_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamOfflineStreamAndConsumerAfterDowngrade — deferred: requires versioning
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires server downgrade and offline stream/consumer handling")]
    public void OfflineStreamAndConsumerAfterDowngrade_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamPersistModeAsync — deferred: requires file store persist mode
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires file store async persist mode configuration")]
    public void PersistModeAsync_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamRemoveTTLOnRemoveMsg — deferred: requires message TTL internals
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires message TTL removal on msg delete")]
    public void RemoveTTLOnRemoveMsg_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamMessageTTLNotExpiring — deferred: requires message TTL internals
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires message TTL non-expiry verification")]
    public void MessageTTLNotExpiring_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamDirectGetBatchParallelWriteDeadlock — deferred: requires direct get batch internals
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires direct get batch parallel write deadlock detection")]
    public void DirectGetBatchParallelWriteDeadlock_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamStreamMirrorWithoutDuplicateWindow — deferred: requires mirror config
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires mirror stream without duplicate window")]
    public void StreamMirrorWithoutDuplicateWindow_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamStreamSourceWithoutDuplicateWindow — deferred: requires source config
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires source stream without duplicate window")]
    public void StreamSourceWithoutDuplicateWindow_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamFileStoreErrorOpeningBlockAfterTruncate — deferred: requires file store fault
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires file store block truncation fault injection")]
    public void FileStoreErrorOpeningBlockAfterTruncate_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamCleanupNoInterestAboveThreshold — deferred: requires consumer interest tracking
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires consumer interest threshold cleanup")]
    public void CleanupNoInterestAboveThreshold_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamStoreFilterIsAll — deferred: requires store filter internals
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires store filter 'all' configuration")]
    public void StoreFilterIsAll_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamFlowControlCrossAccountFanOut — deferred: requires multi-account setup
    // -----------------------------------------------------------------------

    [Fact(Skip = "deferred: requires cross-account flow control with fan-out")]
    public void FlowControlCrossAccountFanOut_ShouldSucceed() { }
}