public extension ObservableType {

    /// Maps each sequence elements to given value.
    ///
    /// - Parameter value: Value to map
    /// - Returns: Sequence where all elements are given value.
    func mapTo<T>(_ value: T) -> Observable<T> {
        return map { _ in value }
    }

    /// Behaves like `take(n)`, but with predicate rather then a fixed number of next events.
    /// It will complete once predicate returns `false`.
    ///
    /// - Parameter predicate: Predicate function that will decide if we should continue or complete
    /// - Returns: Observable of type `E`.
    func takeUntil(predicate: @escaping (Element) -> Bool) -> Observable<Element> {
        return Observable.create { observer in
            return self.subscribe { event in
                switch event {
                case .next(let value):
                    observer.on(.next(value))
                    if !predicate(value) {
                        observer.on(.completed)
                    }
                case .error(let error):
                    observer.on(.error(error))
                case .completed:
                    observer.on(.completed)
                }
            }
        }
    }

}

/// Safely unwraps optional value from chain
func unwrap<T>() -> Driver<T> where Element == Optional<T> {
    return self
        .filter { $0 != nil }
        .map { $0! }
}

/// Creates new subscription and sends elements to `PublishRelay`.
///
/// - Parameter relay: PublishRelay instance
/// - Returns: Disposable for current subscription
func drive(_ relay: PublishRelay<Element>) -> Disposable {
    return drive(onNext: { e in relay.accept(e) })
}

/// Maps each sequence elements to given value.
///
/// - Parameter value: Value to map
/// - Returns: Sequence where all elements are given value.
func mapTo<T>(_ value: T) -> Driver<T> {
    return map { _ in value }
}

public extension Array {

    /// Returns object at provided index, if an index is in bounds of array indices,
    /// otherwise, returns nil.
    ///
    /// - Parameter index: Index of the object that you want to get.
    subscript (safe index: Int) -> Element? {
        return indices ~= index ? self[index] : nil
    }
}

public extension Optional {

    /// Executes `function` if optional is .some, otherwise nothing happens.
    ///
    /// - Parameter function: Function to be executed.
    func forValue(do function: (Wrapped) -> ()) {
        if let value = self {
            function(value)
        }
    }

}

public extension Bool {

    /// If the bool is `true` the provided object is returned, otherwise `nil` is returned.
    ///
    /// - Parameter object: Object to be returned if the bool is `true`.
    /// - Returns: `object` if `true`, `nil` otherwise.
    func mapTrue<T>(to object: T) -> T? {
        return self ? object : nil
    }

}

public extension String {

    /// Checks if string is empty or contains only whitespaces and newlines
    ///
    /// Returns `true` if string is empty or contains only whitespaces and newlines
    var isBlank: Bool {
        return trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
    }

}

public extension UIColor {

    /// Initializes a UIColor object with red, green and blue values,
    /// without the need for dividing the value (red, green or blue) with 255.0,
    /// because this function does that for you.
    ///
    /// - Parameters:
    ///   - r: Red value.
    ///   - g: Green value.
    ///   - b: Blue value.
    ///   - alpha: Alpha value of the color.
    convenience init(r: CGFloat, g: CGFloat, b: CGFloat, alpha: CGFloat = 1) {
        self.init(red: r/255.0, green: g/255.0, blue: b/255.0, alpha: alpha)
    }

        /// Generates a Hex string, from a current color value.
    ///
    /// - Parameter includeAlpha: Boolean value indicating whether the alpha channel should be included in a hex string. Default is false.
    /// - Returns: Hex color string, generated from a current color value.
    func getHex(withAlpha includeAlpha: Bool = false) -> String? {
        guard let components = cgColor.components, components.count >= 3 else {
            return nil
        }

        let r = Float(components[0])
        let g = Float(components[1])
        let b = Float(components[2])
        let a = Float(components.count >= 4 ? components[3] : 1)

        if includeAlpha {
            return String(format: "#%02lX%02lX%02lX%02lX", lroundf(r * 255), lroundf(g * 255), lroundf(b * 255), lroundf(a * 255))
        } else {
            return String(format: "#%02lX%02lX%02lX", lroundf(r * 255), lroundf(g * 255), lroundf(b * 255))
        }
    }
}

public extension UITextView {

    /// Removes all insets from a textView, so it can act more like a label.
    func removeAllInsets() {
        textContainer.lineFragmentPadding = 0
        textContainerInset = .zero
        contentInset = .zero
    }
}