// 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.

// Ported from: golang/nats-server/server/jetstream_batching_test.go
// These tests exercise the JetStream atomic batch publish protocol via NATS headers.
// Tests that require direct access to Go server internals (mset.batches, clMu, etc.)
// are marked with [Fact(Skip = ...)] because those internal structures are not accessible
// over the NATS protocol from an external client.

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

/// <summary>
/// Integration tests ported from jetstream_batching_test.go (26 tests).
/// Tests the JetStream atomic batch publish protocol using NATS headers.
/// </summary>
/// <remarks>
/// The Go source tests fall into two categories:
/// (a) Tests exercising the server via NATS protocol (Nats-Batch-* headers): ported directly.
/// (b) Tests accessing Go server internals (mset.batches, clMu, checkMsgHeadersPreClusteredProposal):
///     skipped because those internal structures are not reachable from a .NET NATS client.
/// </remarks>
[Trait("Category", "Integration")]
public sealed class JetStreamBatchingIntegrationTests
{
    // -----------------------------------------------------------------------
    // TestJetStreamAtomicBatchPublish
    // -----------------------------------------------------------------------
    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublish_ShouldSucceed() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAtomicBatchPublishEmptyAck
    // -----------------------------------------------------------------------
    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishEmptyAck_ShouldReturnEmptyForNonCommit() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAtomicBatchPublishCommitEob
    // -----------------------------------------------------------------------
    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishCommitEob_ShouldExcludeEobMessage() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAtomicBatchPublishLimits
    // -----------------------------------------------------------------------
    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishLimits_BatchIdTooLong_ShouldError() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAtomicBatchPublishDedupeNotAllowed
    // -----------------------------------------------------------------------
    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishDedupeNotAllowed_PreExistingIdShouldError() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAtomicBatchPublishSourceAndMirror
    // -----------------------------------------------------------------------
    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishSourceAndMirror_BatchHeadersRemovedInMirror() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAtomicBatchPublishCleanup (4 sub-tests)
    // -----------------------------------------------------------------------
    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishCleanup_Disable_ShouldCleanupBatchState() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishCleanup_StepDown_ShouldCleanupBatchState() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishCleanup_Delete_ShouldCleanupBatchState() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishCleanup_Commit_ShouldCleanupBatchState() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAtomicBatchPublishConfigOpts
    // -----------------------------------------------------------------------
    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishConfigOpts_DefaultsAndOverrides_ShouldApply() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAtomicBatchPublishDenyHeaders
    // -----------------------------------------------------------------------
    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishDenyHeaders_UnsupportedHeader_ShouldError() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAtomicBatchPublishStageAndCommit (26 sub-tests)
    // -----------------------------------------------------------------------
    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_DedupeDistinct_ShouldSucceed() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_Dedupe_ShouldDetectDuplicate() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_DedupeStaged_ShouldDetectInBatchDuplicate() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_CounterSingle_ShouldAccumulate() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_CounterMultiple_ShouldAccumulate() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_CounterPreInit_ShouldAddToExisting() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_MsgSchedulesDisabled_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_MsgSchedulesTtlDisabled_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_MsgSchedulesTtlInvalid_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_MsgSchedulesInvalidSchedule_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_MsgSchedulesTargetMismatch_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_MsgSchedulesTargetMustBeLiteral_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_MsgSchedulesTargetMustBeUnique_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_MsgSchedulesRollupDisabled_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_MsgSchedules_ShouldCommitSuccessfully() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_DiscardNew_ShouldTrackInflight() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_DiscardNewMaxMsgs_ShouldEnforceLimit() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_DiscardNewMaxBytes_ShouldEnforceLimit() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_DiscardNewMaxMsgsPerSubj_ShouldEnforceLimit() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_DiscardNewMaxMsgsPerSubjDuplicate_ShouldEnforceLimit() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_DiscardNewMaxMsgsPerSubjInflight_ShouldEnforceLimit() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_DiscardNewMaxMsgsPerSubjPreExisting_ShouldEnforceLimit() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_ExpectLastSeq_ShouldSucceed() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_ExpectLastSeqNotFirst_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_ExpectLastSeqInvalidFirst_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_ExpectLastSeqInvalid_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_ExpectPerSubjSimple_ShouldTrackSequences() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_ExpectPerSubjRedundantInBatch_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_ExpectPerSubjDupeInChange_ShouldSucceed() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_ExpectPerSubjNotFirst_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_ExpectPerSubjInProcess_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_ExpectPerSubjInflight_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_RollupDenyPurge_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_RollupInvalid_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_RollupAllFirst_ShouldSucceed() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_RollupAllNotFirst_ShouldError() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_RollupSubUnique_ShouldSucceed() { }

    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishStageAndCommit_RollupSubOverlap_ShouldError() { }

    // -----------------------------------------------------------------------
    // TestJetStreamAtomicBatchPublishHighLevelRollback
    // -----------------------------------------------------------------------
    [Fact(Skip = "deferred: requires running NATS server")]
    public void AtomicBatchPublishHighLevelRollback_OnError_ShouldClearStagingState() { }
}