FrameworkExtensions.swift

import Foundation
import Result
import ReactiveSwift
import ReactiveTask

extension String {

    /// Returns a producer that will enumerate each line of the receiver, then
    /// complete.
    internal var linesProducer: SignalProducer<String, NoError> {
        return SignalProducer { observer, lifetime in
            self.enumerateLines { line, stop in
                observer.send(value: line)

                if lifetime.hasEnded {
                    stop = true
                }
            }

            observer.sendCompleted()
        }
    }
}

extension Signal {
    /// Sends each value that occurs on `signal` combined with each value that
    /// occurs on `otherSignal` (repeats included).
    fileprivate func permute<U>(with otherSignal: Signal<U, Error>) -> Signal<(Value, U), Error> {
        // swiftlint:disable:previous cyclomatic_complexity function_body_length
        return Signal<(Value, U), Error> { observer, lifetime in
            let lock = NSLock()
            lock.name = "org.carthage.CarthageKit.permute"

            var signalValues: [Value] = []
            var signalCompleted = false
            var otherValues: [U] = []
            var otherCompleted = false

            let compositeDisposable = CompositeDisposable()
            lifetime += compositeDisposable

            compositeDisposable += self.observe { event in
                switch event {
                case let .value(value):
                    lock.lock()

                    signalValues.append(value)
                    for otherValue in otherValues {
                        observer.send(value: (value, otherValue))
                    }

                    lock.unlock()

                case let .failed(error):
                    observer.send(error: error)

                case .completed:
                    lock.lock()

                    signalCompleted = true
                    if otherCompleted {
                        observer.sendCompleted()
                    }

                    lock.unlock()

                case .interrupted:
                    observer.sendInterrupted()
                }
            }

            compositeDisposable += otherSignal.observe { event in
                switch event {
                case let .value(value):
                    lock.lock()

                    otherValues.append(value)
                    for signalValue in signalValues {
                        observer.send(value: (signalValue, value))
                    }

                    lock.unlock()

                case let .failed(error):
                    observer.send(error: error)

                case .completed:
                    lock.lock()

                    otherCompleted = true
                    if signalCompleted {
                        observer.sendCompleted()
                    }

                    lock.unlock()

                case .interrupted:
                    observer.sendInterrupted()
                }
            }
        }
    }
}

extension SignalProducer {
    /// Sends each value that occurs on `producer` combined with each value that
    /// occurs on `otherProducer` (repeats included).
    fileprivate func permute<U>(with otherProducer: SignalProducer<U, Error>) -> SignalProducer<(Value, U), Error> {
        return lift(Signal.permute(with:))(otherProducer)
    }

    /// Sends a boolean of whether the producer succeeded or failed.
    internal func succeeded() -> SignalProducer<Bool, NoError> {
        return self
            .then(SignalProducer<Bool, Error>(value: true))
            .flatMapError { _ in .init(value: false) }
    }
}

extension SignalProducer where Value: SignalProducerProtocol, Error == Value.Error {
    /// Sends all permutations of the values from the inner producers, as they arrive.
    ///
    /// If no producers are received, sends a single empty array then completes.
    internal func permute() -> SignalProducer<[Value.Value], Error> {
        return self
            .collect()
            .flatMap(.concat) { (producers: [Value]) -> SignalProducer<[Value.Value], Error> in
                var combined = SignalProducer<[Value.Value], Error>(value: [])

                for producer in producers {
                    combined = combined
                        .permute(with: producer.producer)
                        .map { array, value in
                            var array = array
                            array.append(value)
                            return array
                    }
                }

                return combined
        }
    }
}

extension SignalProducer {
    
    /// Start the producer, then block, waiting for events: `value` and
    /// `completed`.
    ///
    /// When a single value or error is sent, the returned `Result` will
    /// represent those cases. However, when no values are sent, or when more
    /// than one value is sent, a CarthageError.internalError will be returned.
    ///
    /// - returns: Result when single `value` or `failed` event is received.
    ///            CarthageError.internalError when 0 or more than 1 events are received.
    public func only(file: String = #file, line: Int = #line) -> Result<Value, Error> {
        guard let result = self.single() else {
            fatalError("Got no result while result was expected in file \(file) line #\(line)")
        }
        return result
    }
    
    @discardableResult
    public func getOnly(file: String = #file, line: Int = #line) throws -> Value {
        return try self.only(file: file, line: line).get()
    }
}

extension Signal where Value: EventProtocol, Value.Error == Error {
    /// Dematerializes the signal, like dematerialize(), but only yields inner
    /// Error events if no values were sent.
    internal func dematerializeErrorsIfEmpty() -> Signal<Value.Value, Error> {
        return Signal<Value.Value, Error> { observer, lifetime in
            var receivedValue = false
            var receivedError: Error?

            lifetime += self.observe { event in
                switch event {
                case let .value(innerEvent):
                    switch innerEvent.event {
                    case let .value(value):
                        receivedValue = true
                        observer.send(value: value)

                    case let .failed(error):
                        receivedError = error

                    case .completed:
                        observer.sendCompleted()

                    case .interrupted:
                        observer.sendInterrupted()
                    }

                case let .failed(error):
                    observer.send(error: error)

                case .completed:
                    if let receivedError = receivedError, !receivedValue {
                        observer.send(error: receivedError)
                    }

                    observer.sendCompleted()

                case .interrupted:
                    observer.sendInterrupted()
                }
            }
        }
    }
}

extension SignalProducer where Value: EventProtocol, Value.Error == Error {
    /// Dematerializes the producer, like dematerialize(), but only yields inner
    /// Error events if no values were sent.
    internal func dematerializeErrorsIfEmpty() -> SignalProducer<Value.Value, Error> {
        return lift { $0.dematerializeErrorsIfEmpty() }
    }
}

typealias CarthageResult<Value> = Result<Value, CarthageError>

extension Result where Error == CarthageError {
    /// Constructs a result from a throwing closure taking a `URL`, failing with `CarthageError` if throw occurs.
    /// - parameter carthageError: Defaults to `CarthageError.writeFailed`.
    internal init(
        at url: URL,
        carthageError: (URL, NSError) -> CarthageError = CarthageError.writeFailed,
        attempt closure: (URL) throws -> Value
        ) {
        do {
            self = .success(try closure(url))
        } catch let error as NSError {
            self = .failure(carthageError(url, error))
        }
    }
    
    static func catching(file: String = #file, line: Int = #line, _ body: () throws -> Success) -> CarthageResult<Value> {
        do {
            return .success(try body())
        } catch let error as CarthageError {
            return .failure(error)
        } catch {
            return .failure(CarthageError.assertionError(file: file, line: line, description: "Unexpected error thrown: \(error)"))
        }
    }
}

extension URL {
    fileprivate func volumeSupportsFileCloning() throws -> Bool {
        guard #available(macOS 10.12, *) else { return false }

        let key = URLResourceKey.volumeSupportsFileCloningKey
        let values = try self.resourceValues(forKeys: [key]).allValues

        func error(failureReason: String) -> NSError {
            return NSError(
                domain: NSCocoaErrorDomain,
                code: CocoaError.fileReadUnknown.rawValue,
                userInfo: [NSURLErrorKey: self, NSLocalizedFailureReasonErrorKey: failureReason]
            )
        }

        guard values.count == 1 else {
            throw error(failureReason: "Expected single resource value: «actual count: \(values.count)».")
        }

        guard let volumeSupportsFileCloning = values[key] as? NSNumber else {
            throw error(failureReason: "Unable to extract a NSNumber from «\(String(describing: values.first))».")
        }

        return volumeSupportsFileCloning.boolValue
    }
}

extension FileManager: ReactiveExtensionsProvider {
    @available(*, deprecated, message: "Use reactive.enumerator instead")
    public func carthage_enumerator(
        at url: URL, includingPropertiesForKeys keys: [URLResourceKey]? = nil,
        options: FileManager.DirectoryEnumerationOptions = [],
        catchErrors: Bool = false
        ) -> SignalProducer<(FileManager.DirectoryEnumerator, URL), CarthageError> {
        return reactive.enumerator(at: url, includingPropertiesForKeys: keys, options: options, catchErrors: catchErrors)
    }

    // swiftlint:disable identifier_name
    /// rdar://32984063 When on APFS, `FileManager.copyItem(at:to)` can result in zero'd out binary files, due to the cloning functionality.
    /// To avoid this, we drop down to the copyfile c API, explicitly not passing the 'CLONE' flags so we always copy the data normally.
    /// - Parameter avoiding·rdar·32984063: When `false`, passthrough to Foundation’s `FileManager.copyItem(at:to:)`.
    internal func copyItem(at from: URL, to: URL, avoiding·rdar·32984063: Bool) throws {
        guard avoiding·rdar·32984063, try from.volumeSupportsFileCloning() else {
            return try self.copyItem(at: from, to: to)
        }

        try from.path.withCString { fromCStr in
            try to.path.withCString { toCStr in
                let state = copyfile_state_alloc()
                // Can't use COPYFILE_NOFOLLOW. Restriction relaxed to COPYFILE_NOFOLLOW_SRC
                // http://openradar.appspot.com/32984063
                let status = copyfile(fromCStr, toCStr, state, UInt32(COPYFILE_ALL | COPYFILE_RECURSIVE | COPYFILE_NOFOLLOW_SRC))
                copyfile_state_free(state)
                if status < 0 {
                    throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno), userInfo: nil)
                }
            }
        }
    }
}

extension Reactive where Base: FileManager {
    /// Creates a directory enumerator at the given URL. Sends each URL
    /// enumerated, along with the enumerator itself (so it can be introspected
    /// and modified as enumeration progresses).
    public func enumerator(
        at url: URL,
        includingPropertiesForKeys keys: [URLResourceKey]? = nil,
        options: FileManager.DirectoryEnumerationOptions = [],
        catchErrors: Bool = false
        ) -> SignalProducer<(FileManager.DirectoryEnumerator, URL), CarthageError> {
        return SignalProducer { [base = self.base] observer, lifetime in
            let enumerator = base.enumerator(at: url, includingPropertiesForKeys: keys, options: options) { url, error in
                if catchErrors {
                    return true
                } else {
                    observer.send(error: CarthageError.readFailed(url, error as NSError))
                    return false
                }
                }!

            while !lifetime.hasEnded {
                if let url = enumerator.nextObject() as? URL {
                    let value = (enumerator, url)
                    observer.send(value: value)
                } else {
                    break
                }
            }

            observer.sendCompleted()
        }
    }

    /// Creates a temporary directory with the given template name. Sends the
    /// URL of the temporary directory and completes if successful, else errors.
    ///
    /// The template name should adhere to the format required by the mkdtemp()
    /// function.
    public func createTemporaryDirectoryWithTemplate(_ template: String) -> SignalProducer<URL, CarthageError> {
        return SignalProducer { [base = self.base] () -> Result<URL, CarthageError> in
            return base.createTemporaryDirectoryWithTemplate(template)
        }
    }

    public func createTemporaryDirectory() -> SignalProducer<URL, CarthageError> {
        return createTemporaryDirectoryWithTemplate(Files.tempDirTemplate)
    }
}

extension FileManager {
    func createTemporaryDirectory() -> Result<URL, CarthageError> {
        return createTemporaryDirectoryWithTemplate(Files.tempDirTemplate)
    }
    
    func createTemporaryDirectoryWithTemplate(_ template: String) -> Result<URL, CarthageError> {
        
        let temporaryDirectory: NSString
        if #available(macOS 10.12, *) {
            temporaryDirectory = self.temporaryDirectory.path as NSString
        } else {
            temporaryDirectory = NSTemporaryDirectory() as NSString
        }

        var temporaryDirectoryTemplate: ContiguousArray<CChar> = temporaryDirectory.appendingPathComponent(template).utf8CString

        let result: UnsafeMutablePointer<Int8>? = temporaryDirectoryTemplate
            .withUnsafeMutableBufferPointer { (template: inout UnsafeMutableBufferPointer<CChar>) -> UnsafeMutablePointer<CChar> in
                mkdtemp(template.baseAddress)
        }

        if result == nil {
            return .failure(.taskError(.posixError(errno)))
        }

        let temporaryPath = temporaryDirectoryTemplate.withUnsafeBufferPointer { (ptr: UnsafeBufferPointer<CChar>) -> String in
            return String(validatingUTF8: ptr.baseAddress!)!
        }

        return .success(URL(fileURLWithPath: temporaryPath, isDirectory: true))
    }
}

private let defaultSessionError = NSError(domain: Constants.bundleIdentifier, code: 1, userInfo: nil)

extension Reactive where Base: URLSession {
    /// Returns a SignalProducer which performs a downloadTask associated with an
    /// `NSURLSession`
    ///
    /// - parameters:
    ///   - request: A request that will be performed when the producer is
    ///              started
    ///
    /// - returns: A producer that will execute the given request once for each
    ///            invocation of `start()`.
    ///
    /// - note: This method will not send an error event in the case of a server
    ///         side error (i.e. when a response with status code other than
    ///         200...299 is received).
    internal func download(with request: URLRequest) -> SignalProducer<(URL, URLResponse), AnyError> {
        return SignalProducer { [base = self.base] observer, lifetime in
            let task = base.downloadTask(with: request) { url, response, error in
                if let url = url, let response = response {
                    observer.send(value: (url, response))
                    observer.sendCompleted()
                } else {
                    observer.send(error: AnyError(error ?? defaultSessionError))
                }
            }

            lifetime.observeEnded {
                task.cancel()
            }
            task.resume()
        }
    }
}

extension Task {

    init(launchCommand: String, shell: String = "/bin/sh", workingDirectoryPath: String? = nil, environment: [String: String]? = nil) {
        let arguments = ["-c", launchCommand]
        self.init(shell, arguments: arguments, workingDirectoryPath: workingDirectoryPath, environment: environment)
    }

    func getData(input: Data? = nil) -> Result<(stdOut: Data, stdErr: Data), TaskError> {
        var stdOutData = Data()
        var stdErrData = Data()
        return launch(standardInput: input.map { SignalProducer(value: $0) })
            .on(value: { (taskEvent: TaskEvent<Data>) in
                switch taskEvent {
                case .standardError(let data):
                    stdOutData += data
                case .standardOutput(let data):
                    stdErrData += data
                default:
                    break
                }
            }
            )
            .wait()
            .map { return (stdOutData, stdErrData) }
    }

    func getStdOutData(input: Data? = nil) -> Result<Data, TaskError> {
        return launch(standardInput: input.map { SignalProducer(value: $0) })
            .ignoreTaskData()
            .first() ?? Result.success(Data())
    }

    func getStdOutString(input: Data? = nil, encoding: String.Encoding = .utf8) -> Result<String, TaskError> {
        return getStdOutData(input: input)
            .map { String(data: $0, encoding: encoding) ?? "" }
    }
}