//===----------------------------------------------------------------------===//

//

// This source file is part of the SwiftNIO open source project

//

// Copyright (c) 2025 Apple Inc. and the SwiftNIO project authors

// Licensed under Apache License v2.0

//

// See LICENSE.txt for license information

// See CONTRIBUTORS.txt for the list of SwiftNIO project authors

//

// SPDX-License-Identifier: Apache-2.0

//

//===----------------------------------------------------------------------===//

@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)

extension AsyncSequence where Element == ByteBuffer {

    /// Returns the longest possible subsequences of the sequence, in order,

    /// that are separated by line breaks.

    ///

    /// The following Characters are considered line breaks, similar to

    /// standard library's `String.split(whereSeparator: \.isNewline)`:

    /// - "\n" (U+000A): LINE FEED (LF)

    /// - U+000B: LINE TABULATION (VT)

    /// - U+000C: FORM FEED (FF)

    /// - "\r" (U+000D): CARRIAGE RETURN (CR)

    /// - "\r\n" (U+000D U+000A): CR-LF

    ///

    /// The following Characters are NOT considered line breaks, unlike in

    /// standard library's `String.split(whereSeparator: \.isNewline)`:

    /// - U+0085: NEXT LINE (NEL)

    /// - U+2028: LINE SEPARATOR

    /// - U+2029: PARAGRAPH SEPARATOR

    ///

    /// This is because these characters would require unicode and data-encoding awareness, which

    /// are outside swift-nio's scope.

    ///

    /// Usage:

    /// ```swift

    /// let baseSequence = MyAsyncSequence<ByteBuffer>(...)

    /// let splitLinesSequence = baseSequence.splitLines()

    ///

    /// for try await buffer in splitLinesSequence {

    ///     print("Split by line breaks!\n", buffer.hexDump(format: .detailed))

    /// }

    /// ```

    ///

    /// - Parameters:

    ///   - omittingEmptySubsequences: If `false`, an empty subsequence is

    ///     returned in the result for each consecutive line break in the sequence.

    ///     If `true`, only nonempty subsequences are returned. The default value is `true`.

    ///   - maximumBufferSize: The maximum number of bytes to aggregate in-memory.

    ///     An error will be thrown if after decoding an element there is more aggregated data than this amount.

    /// - Returns: An `AsyncSequence` of ``ByteBuffer``s, split from the this async sequence's bytes.

    ///

    /// - Complexity: O(*n*), where *n* is the length of the file.

    @inlinable

    public func splitLines(

        omittingEmptySubsequences: Bool = true,

        maximumBufferSize: Int? = nil

    ) -> NIODecodedAsyncSequence<Self, NIOSplitLinesMessageDecoder> {

        self.decode(

            using: NIOSplitLinesMessageDecoder(

                omittingEmptySubsequences: omittingEmptySubsequences

            ),

            maximumBufferSize: maximumBufferSize

        )

    }

    /// Returns the longest possible `String`s of the sequence, in order,

    /// that are separated by line breaks.

    ///

    /// The following Characters are considered line breaks, similar to

    /// standard library's `String.split(whereSeparator: \.isNewline)`:

    /// - "\n" (U+000A): LINE FEED (LF)

    /// - U+000B: LINE TABULATION (VT)

    /// - U+000C: FORM FEED (FF)

    /// - "\r" (U+000D): CARRIAGE RETURN (CR)

    /// - "\r\n" (U+000D U+000A): CR-LF

    ///

    /// The following Characters are NOT considered line breaks, unlike in

    /// standard library's `String.split(whereSeparator: \.isNewline)`:

    /// - U+0085: NEXT LINE (NEL)

    /// - U+2028: LINE SEPARATOR

    /// - U+2029: PARAGRAPH SEPARATOR

    ///

    /// This is because these characters would require unicode and data-encoding awareness, which

    /// are outside swift-nio's scope.

    ///

    /// Usage:

    /// ```swift

    /// let baseSequence = MyAsyncSequence<ByteBuffer>(...)

    /// let splitLinesSequence = baseSequence.splitUTF8Lines()

    ///

    /// for try await string in splitLinesSequence {

    ///     print("Split by line breaks!\n", string)

    /// }

    /// ```

    ///

    /// - Parameters:

    ///   - omittingEmptySubsequences: If `false`, an empty subsequence is

    ///     returned in the result for each consecutive line break in the sequence.

    ///     If `true`, only nonempty subsequences are returned. The default value is `true`.

    ///   - maximumBufferSize: The maximum number of bytes to aggregate in-memory.

    ///     An error will be thrown if after decoding an element there is more aggregated data than this amount.

    /// - Returns: An `AsyncSequence` of `String`s, split from the this async sequence's bytes.

    ///

    /// - Complexity: O(*n*), where *n* is the length of the file.

    @inlinable

    public func splitUTF8Lines(

        omittingEmptySubsequences: Bool = true,

        maximumBufferSize: Int? = nil

    ) -> NIODecodedAsyncSequence<Self, NIOSplitUTF8LinesMessageDecoder> {

        self.decode(

            using: NIOSplitUTF8LinesMessageDecoder(

                omittingEmptySubsequences: omittingEmptySubsequences

            ),

            maximumBufferSize: maximumBufferSize

        )

    }

}

// MARK: - SplitMessageDecoder

/// A decoder which splits the data into subsequences that are separated by a given separator.

/// Similar to standard library's `String.split(separator:maxSplits:omittingEmptySubsequences:)`.

///

/// This decoder can be used to introduce a `AsyncSequence/split(omittingEmptySubsequences:maximumBufferSize:whereSeparator:)`

/// function. We could not come up with valid use-cases for such a function so we held off on introducing it.

/// See https://github.com/apple/swift-nio/pull/3411 for more info if you need such a function.

@usableFromInline

struct SplitMessageDecoder: NIOSingleStepByteToMessageDecoder {

    @usableFromInline

    typealias InboundOut = ByteBuffer

    @usableFromInline

    let omittingEmptySubsequences: Bool

    @usableFromInline

    let isSeparator: (UInt8) -> Bool

    @usableFromInline

    var ended: Bool

    @usableFromInline

    var bytesWithNoSeparatorsCount: Int

    @inlinable

    init(

        omittingEmptySubsequences: Bool = true,

        whereSeparator isSeparator: @escaping (UInt8) -> Bool

    ) {

        self.omittingEmptySubsequences = omittingEmptySubsequences

        self.isSeparator = isSeparator

        self.ended = false

        self.bytesWithNoSeparatorsCount = 0

    }

    /// Decode the next message from the given buffer.

    @inlinable

    mutating func decode(

        buffer: inout ByteBuffer,

        hasReceivedLastChunk: Bool

    ) throws -> (buffer: InboundOut, separator: UInt8?)? {

        if self.ended { return nil }

        while true {

            let startIndex = buffer.readerIndex + self.bytesWithNoSeparatorsCount

            if let separatorIndex = buffer.readableBytesView[startIndex...].firstIndex(where: self.isSeparator) {

                // Safe to force unwrap. We just found a separator somewhere in the buffer.

                let slice = buffer.readSlice(length: separatorIndex - buffer.readerIndex)!

                // Reset for the next search since we found a separator.

                self.bytesWithNoSeparatorsCount = 0

                if self.omittingEmptySubsequences,

                    slice.readableBytes == 0

                {

                    // Mark the separator itself as read

                    buffer._moveReaderIndex(forwardBy: 1)

                    continue

                }

                // Read the separator itself

                // Safe to force unwrap. We just found a separator somewhere in the buffer.

                let separator = buffer.readInteger(as: UInt8.self)!

                return (slice, separator)

            } else {

                guard hasReceivedLastChunk else {

                    // Make sure we don't double-check these no-separator bytes again.

                    self.bytesWithNoSeparatorsCount = buffer.readableBytes

                    // Need more data

                    return nil

                }

                // At this point, we're ending the decoding process.

                self.ended = true

                if self.omittingEmptySubsequences,

                    buffer.readableBytes == 0

                {

                    return nil

                }

                // Just send the whole buffer if we're at the last chunk but we can find no separators

                // Safe to force unwrap. `buffer.readableBytes` is `0` in the worst case.

                let slice = buffer.readSlice(length: buffer.readableBytes)!

                return (slice, nil)

            }

        }

    }

    /// Decode the next message separated by the provided separator.

    /// To be used when we're still receiving data.

    @inlinable

    mutating func decode(buffer: inout ByteBuffer) throws -> InboundOut? {

        try self.decode(buffer: &buffer, hasReceivedLastChunk: false)?.buffer

    }

    /// Decode the next message separated by the provided separator.

    /// To be used when the last chunk of data has been received.

    @inlinable

    mutating func decodeLast(buffer: inout ByteBuffer, seenEOF: Bool) throws -> InboundOut? {

        try self.decode(buffer: &buffer, hasReceivedLastChunk: true)?.buffer

    }

}

@available(*, unavailable)

extension SplitMessageDecoder: Sendable {}

// MARK: - NIOSplitLinesMessageDecoder

/// A decoder which splits the data into subsequences that are separated by line breaks.

///

/// You can initialize this type directly, or use

/// `AsyncSequence/splitLines(omittingEmptySubsequences:maximumBufferSize:)` to create a

/// `NIODecodedAsyncSequence` that uses this decoder.

///

/// The following Characters are considered line breaks, similar to

/// standard library's `String.split(whereSeparator: \.isNewline)`:

/// - "\n" (U+000A): LINE FEED (LF)

/// - U+000B: LINE TABULATION (VT)

/// - U+000C: FORM FEED (FF)

/// - "\r" (U+000D): CARRIAGE RETURN (CR)

/// - "\r\n" (U+000D U+000A): CR-LF

///

/// The following Characters are NOT considered line breaks, unlike in

/// standard library's `String.split(whereSeparator: \.isNewline)`:

/// - U+0085: NEXT LINE (NEL)

/// - U+2028: LINE SEPARATOR

/// - U+2029: PARAGRAPH SEPARATOR

///

/// This is because these characters would require unicode and data-encoding awareness, which

/// are outside swift-nio's scope.

///

/// Usage:

/// ```swift

/// let baseSequence = MyAsyncSequence<ByteBuffer>(...)

/// let splitLinesSequence = baseSequence.splitLines()

///

/// for try await buffer in splitLinesSequence {

///     print("Split by line breaks!\n", buffer.hexDump(format: .detailed))

/// }

/// ```

public struct NIOSplitLinesMessageDecoder: NIOSingleStepByteToMessageDecoder {

    public typealias InboundOut = ByteBuffer

    @usableFromInline

    var splitDecoder: SplitMessageDecoder

    @usableFromInline

    var previousSeparatorWasCR: Bool

    @inlinable

    public init(omittingEmptySubsequences: Bool) {

        self.splitDecoder = SplitMessageDecoder(

            omittingEmptySubsequences: omittingEmptySubsequences,

            whereSeparator: Self.isLineBreak

        )

        self.previousSeparatorWasCR = false

    }

    /// - ASCII 10 - "\n" (U+000A): LINE FEED (LF)

    /// - ASCII 11 - U+000B: LINE TABULATION (VT)

    /// - ASCII 12 - U+000C: FORM FEED (FF)

    /// - ASCII 13 - "\r" (U+000D): CARRIAGE RETURN (CR)

    ///

    /// "\r\n" is manually accounted for during the decoding.

    @inlinable

    static func isLineBreak(_ byte: UInt8) -> Bool {

        /// All the 4 ASCII bytes are in range of \n to \r.

        (UInt8(ascii: "\n")...UInt8(ascii: "\r")).contains(byte)

    }

    /// Decode the next message from the given buffer.

    @inlinable

    mutating func decode(buffer: inout ByteBuffer, hasReceivedLastChunk: Bool) throws -> InboundOut? {

        while true {

            guard

                let (slice, separator) = try self.splitDecoder.decode(

                    buffer: &buffer,

                    hasReceivedLastChunk: hasReceivedLastChunk

                )

            else {

                return nil

            }

            // If we are getting rid of empty subsequences then it doesn't matter if we detect

            // \r\n as a CR-LF, or as a CR + a LF. The backing decoder gets rid of the empty subsequence

            // anyway. Therefore, we can return early right here and skip the rest of the logic.

            if self.splitDecoder.omittingEmptySubsequences {

                return slice

            }

            // "\r\n" is 2 bytes long, so we need to manually account for it.

            switch separator {

            case UInt8(ascii: "\n") where slice.readableBytes == 0:

                let isCRLF = self.previousSeparatorWasCR

                self.previousSeparatorWasCR = false

                if isCRLF {

                    continue

                }

            case UInt8(ascii: "\r"):

                self.previousSeparatorWasCR = true

            default:

                self.previousSeparatorWasCR = false

            }

            return slice

        }

    }

    /// Decode the next message separated by one of the ASCII line breaks.

    /// To be used when we're still receiving data.

    @inlinable

    public mutating func decode(buffer: inout ByteBuffer) throws -> InboundOut? {

        try self.decode(buffer: &buffer, hasReceivedLastChunk: false)

    }

    /// Decode the next message separated by one of the ASCII line breaks.

    /// To be used when the last chunk of data has been received.

    @inlinable

    public mutating func decodeLast(buffer: inout ByteBuffer, seenEOF: Bool) throws -> InboundOut? {

        try self.decode(buffer: &buffer, hasReceivedLastChunk: true)

    }

}

@available(*, unavailable)

extension NIOSplitLinesMessageDecoder: Sendable {}

// MARK: - NIOSplitUTF8LinesMessageDecoder

/// A decoder which splits the data into subsequences that are separated by line breaks.

///

/// You can initialize this type directly, or use

/// `AsyncSequence/splitUTF8Lines(omittingEmptySubsequences:maximumBufferSize:)` to create a

/// `NIODecodedAsyncSequence` that uses this decoder.

///

/// The following Characters are considered line breaks, similar to

/// standard library's `String.split(whereSeparator: \.isNewline)`:

/// - "\n" (U+000A): LINE FEED (LF)

/// - U+000B: LINE TABULATION (VT)

/// - U+000C: FORM FEED (FF)

/// - "\r" (U+000D): CARRIAGE RETURN (CR)

/// - "\r\n" (U+000D U+000A): CR-LF

///

/// The following Characters are NOT considered line breaks, unlike in

/// standard library's `String.split(whereSeparator: \.isNewline)`:

/// - U+0085: NEXT LINE (NEL)

/// - U+2028: LINE SEPARATOR

/// - U+2029: PARAGRAPH SEPARATOR

///

/// This is because these characters would require unicode and data-encoding awareness, which

/// are outside swift-nio's scope.

///

/// Usage:

/// ```swift

/// let baseSequence = MyAsyncSequence<ByteBuffer>(...)

/// let splitLinesSequence = baseSequence.splitUTF8Lines()

///

/// for try await string in splitLinesSequence {

///     print("Split by line breaks!\n", string)

/// }

/// ```

public struct NIOSplitUTF8LinesMessageDecoder: NIOSingleStepByteToMessageDecoder {

    public typealias InboundOut = String

    @usableFromInline

    var splitLinesDecoder: NIOSplitLinesMessageDecoder

    @inlinable

    public init(omittingEmptySubsequences: Bool) {

        self.splitLinesDecoder = NIOSplitLinesMessageDecoder(

            omittingEmptySubsequences: omittingEmptySubsequences

        )

    }

    /// Decode the next message separated by one of the ASCII line breaks.

    /// To be used when we're still receiving data.

    @inlinable

    public mutating func decode(buffer: inout ByteBuffer) throws -> InboundOut? {

        try self.splitLinesDecoder.decode(buffer: &buffer, hasReceivedLastChunk: false).map {

            String(buffer: $0)

        }

    }

    /// Decode the next message separated by one of the ASCII line breaks.

    /// To be used when the last chunk of data has been received.

    @inlinable

    public mutating func decodeLast(buffer: inout ByteBuffer, seenEOF: Bool) throws -> InboundOut? {

        try self.splitLinesDecoder.decode(buffer: &buffer, hasReceivedLastChunk: true).map {

            String(buffer: $0)

        }

    }

}

@available(*, unavailable)

extension NIOSplitUTF8LinesMessageDecoder: Sendable {}