// Independent LF framing example and executable regression checks; no project source is reproduced.
using System.Text;

/// <summary>Extracts LF-delimited byte payloads using fixed-capacity candidate storage.</summary>
/// <remarks>Single-consumer example. Returned frames allocate; input errors terminate this instance.</remarks>
public sealed class BoundedLfFramer
{
    private readonly byte[] _candidate;
    private int _length;
    private bool _stopped;

    /// <summary>Allocates storage for a positive payload limit, excluding LF; otherwise throws.</summary>
    public BoundedLfFramer(int maximumPayloadLength)
    {
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(maximumPayloadLength);
        _candidate = new byte[maximumPayloadLength];
    }

    /// <summary>Returns complete payload copies and retains incomplete input; throws on excess size or reuse.</summary>
    public IReadOnlyList<byte[]> Append(ReadOnlySpan<byte> input)
    {
        ObjectDisposedException.ThrowIf(_stopped, this);
        var frames = new List<byte[]>();
        foreach (byte value in input)
        {
            if (value == (byte)'\n')
            {
                frames.Add(_candidate.AsSpan(0, _length).ToArray());
                _length = 0;
                continue;
            }

            if (_length == _candidate.Length)
                Reject("Payload exceeds the configured limit.");

            _candidate[_length++] = value;
        }
        return frames;
    }

    /// <summary>Ends the stream, rejecting incomplete input or reuse with an exception.</summary>
    public void Complete()
    {
        ObjectDisposedException.ThrowIf(_stopped, this);
        if (_length != 0)
            Reject("Stream ended with an incomplete payload.");
        _stopped = true;
    }

    /// <summary>Marks this instance unusable and throws an input error with the supplied reason.</summary>
    private void Reject(string reason)
    {
        _stopped = true;
        throw new InvalidDataException(reason);
    }
}

/// <summary>Runs dependency-free framing checks, returning zero only when every check passes.</summary>
internal static class Program
{
    /// <summary>Executes the example checks; a failed assertion terminates with an exception.</summary>
    private static void Main()
    {
        PreservesFramesAcrossEveryPartition();
        AcceptsBoundaryAndEmptyPayloads();
        RejectsOversizedPayloads();
        RejectsIncompleteEofAndReuse();
        RejectsInvalidLimits();
        Console.WriteLine("Passed: 256 input partitions and boundary, empty-input, oversize, EOF and lifecycle checks.");
    }

    /// <summary>Checks all 256 possible partitions of the nine-byte sample against identical ordered output.</summary>
    private static void PreservesFramesAcrossEveryPartition()
    {
        // Arrange
        byte[] stream = Encoding.ASCII.GetBytes("RED\nBLUE\n");
        for (int partition = 0; partition < 1 << (stream.Length - 1); partition++)
        {
            var framer = new BoundedLfFramer(4);
            var actual = new List<string>();
            int start = 0;

            // Act
            for (int end = 1; end <= stream.Length; end++)
            {
                if (end != stream.Length && (partition & (1 << (end - 1))) == 0)
                    continue;
                actual.AddRange(framer.Append(stream.AsSpan(start, end - start)).Select(Encoding.ASCII.GetString));
                start = end;
            }
            framer.Complete();

            // Assert
            Require(actual.SequenceEqual(new[] { "RED", "BLUE" }), "Partition changed frame output.");
        }
    }

    /// <summary>Checks exact-limit, empty-frame and zero-length-input semantics.</summary>
    private static void AcceptsBoundaryAndEmptyPayloads()
    {
        // Arrange
        var framer = new BoundedLfFramer(4);

        // Act
        var empty = framer.Append(ReadOnlySpan<byte>.Empty);
        var frames = framer.Append("ABCD\n\n"u8);
        framer.Complete();

        // Assert
        Require(empty.Count == 0, "Empty input emitted a frame.");
        Require(frames.Count == 2 && frames[0].AsSpan().SequenceEqual("ABCD"u8) && frames[1].Length == 0,
            "Exact-limit or empty-frame handling failed.");
    }

    /// <summary>Checks oversized payloads with a delimiter, without one, and split across chunks.</summary>
    private static void RejectsOversizedPayloads()
    {
        // Arrange
        var complete = new BoundedLfFramer(4);
        var incomplete = new BoundedLfFramer(4);
        var fragmented = new BoundedLfFramer(4);
        fragmented.Append("ABCD"u8);

        // Act / Assert
        Expect<InvalidDataException>(() => complete.Append("ABCDE\n"u8));
        Expect<InvalidDataException>(() => incomplete.Append("ABCDE"u8));
        Expect<InvalidDataException>(() => fragmented.Append("E\n"u8));
    }

    /// <summary>Checks rejection of an incomplete EOF and all subsequent use of closed instances.</summary>
    private static void RejectsIncompleteEofAndReuse()
    {
        // Arrange
        var incomplete = new BoundedLfFramer(4);
        incomplete.Append("ABC"u8);
        var completed = new BoundedLfFramer(4);

        // Act / Assert
        Expect<InvalidDataException>(incomplete.Complete);
        Expect<ObjectDisposedException>(() => incomplete.Append("\n"u8));
        completed.Complete();
        Expect<ObjectDisposedException>(completed.Complete);
    }

    /// <summary>Checks that zero and negative candidate capacities are rejected.</summary>
    private static void RejectsInvalidLimits()
    {
        // Arrange / Act / Assert
        Expect<ArgumentOutOfRangeException>(() => new BoundedLfFramer(0));
        Expect<ArgumentOutOfRangeException>(() => new BoundedLfFramer(-1));
    }

    /// <summary>Throws when the supplied condition fails, identifying the assertion.</summary>
    private static void Require(bool condition, string reason)
    {
        if (!condition)
            throw new InvalidOperationException(reason);
    }

    /// <summary>Verifies that an operation throws the expected exception type; otherwise throws.</summary>
    private static void Expect<TException>(Action operation) where TException : Exception
    {
        try
        {
            operation();
        }
        catch (TException)
        {
            return;
        }
        throw new InvalidOperationException($"Expected {typeof(TException).Name}.");
    }
}