//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftNIO open source project
//
// Copyright (c) 2020 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
//
//===----------------------------------------------------------------------===//

import NIO
import NIOFoundationCompat
import class Foundation.Pipe

internal struct OutputGrepper {
    internal var result: EventLoopFuture<ProgramOutput>
    internal var processOutputPipe: NIOFileHandle

    internal static func make(group: EventLoopGroup) -> OutputGrepper {
        let processToChannel = Pipe()
        let deadPipe = Pipe() // just so we have an output...

        let eventLoop = group.next()
        let outputPromise = eventLoop.makePromise(of: ProgramOutput.self)

        // We gotta `dup` everything because Pipe is bad and closes file descriptors on `deinit` :(
        let channelFuture = NIOPipeBootstrap(group: group)
            .channelOption(ChannelOptions.allowRemoteHalfClosure, value: true)
            .channelInitializer { channel in
                channel.pipeline.addHandlers([ByteToMessageHandler(NewlineFramer()),
                                              GrepHandler(promise: outputPromise)])
            }
            .withPipes(inputDescriptor: dup(processToChannel.fileHandleForReading.fileDescriptor),
                       outputDescriptor: dup(deadPipe.fileHandleForWriting.fileDescriptor))
        let processOutputPipe = NIOFileHandle(descriptor: dup(processToChannel.fileHandleForWriting.fileDescriptor))
        processToChannel.fileHandleForReading.closeFile()
        processToChannel.fileHandleForWriting.closeFile()
        deadPipe.fileHandleForReading.closeFile()
        deadPipe.fileHandleForWriting.closeFile()
        channelFuture.cascadeFailure(to: outputPromise)
        return OutputGrepper(result: outputPromise.futureResult,
                             processOutputPipe: processOutputPipe)
    }
}

typealias ProgramOutput = String

private final class GrepHandler: ChannelInboundHandler {
    typealias InboundIn = String

    private let promise: EventLoopPromise<ProgramOutput>

    init(promise: EventLoopPromise<ProgramOutput>) {
        self.promise = promise
    }

    func errorCaught(context: ChannelHandlerContext, error: Error) {
        self.promise.fail(error)
        context.close(promise: nil)
    }

    func channelRead(context: ChannelHandlerContext, data: NIOAny) {
        let line = self.unwrapInboundIn(data)
        if line.lowercased().contains("fatal error") ||
            line.lowercased().contains("precondition failed") ||
            line.lowercased().contains("assertion failed") {
            self.promise.succeed(line)
            context.close(promise: nil)
        }
    }

    func userInboundEventTriggered(context: ChannelHandlerContext, event: Any) {
        if case .some(.inputClosed) = event as? ChannelEvent {
            self.promise.succeed("")
            context.close(promise: nil)
        }
    }

    func handlerRemoved(context: ChannelHandlerContext) {
        self.promise.fail(ChannelError.alreadyClosed)
    }
}

private struct NewlineFramer: ByteToMessageDecoder {
    typealias InboundOut = String

    func decode(context: ChannelHandlerContext, buffer: inout ByteBuffer) throws -> DecodingState {
        if let firstNewline = buffer.readableBytesView.firstIndex(of: UInt8(ascii: "\n")) {
            let length = firstNewline - buffer.readerIndex + 1
            context.fireChannelRead(self.wrapInboundOut(String(buffer.readString(length: length)!.dropLast())))
            return .continue
        } else {
            return .needMoreData
        }
    }
}
