// The MIT License (MIT)
//
// Copyright (c) 2017-2020 Alexander Grebenyuk (github.com/kean).

#if os(iOS) || os(tvOS)
import UIKit

internal protocol LayoutItem { // `UIView`, `UILayoutGuide`
    var superview: UIView? { get }
}

extension UIView: LayoutItem {}
extension UILayoutGuide: LayoutItem {
    internal var superview: UIView? { owningView }
}
#elseif os(macOS)
import AppKit

internal protocol LayoutItem { // `NSView`, `NSLayoutGuide`
    var superview: NSView? { get }
}

extension NSView: LayoutItem {}
extension NSLayoutGuide: LayoutItem {
    internal var superview: NSView? { owningView }
}
#endif

internal extension LayoutItem { // Align methods are available via `LayoutAnchors`
    @nonobjc var anchors: LayoutAnchors<Self> { LayoutAnchors(base: self) }
}

// MARK: - LayoutAnchors

internal struct LayoutAnchors<Base> {
    internal let base: Base
}

internal extension LayoutAnchors where Base: LayoutItem {

    // MARK: Anchors

    var top: Anchor<AnchorType.Edge, AnchorAxis.Vertical> { Anchor(base, .top) }
    var bottom: Anchor<AnchorType.Edge, AnchorAxis.Vertical> { Anchor(base, .bottom) }
    var left: Anchor<AnchorType.Edge, AnchorAxis.Horizontal> { Anchor(base, .left) }
    var right: Anchor<AnchorType.Edge, AnchorAxis.Horizontal> { Anchor(base, .right) }
    var leading: Anchor<AnchorType.Edge, AnchorAxis.Horizontal> { Anchor(base, .leading) }
    var trailing: Anchor<AnchorType.Edge, AnchorAxis.Horizontal> { Anchor(base, .trailing) }

    var centerX: Anchor<AnchorType.Center, AnchorAxis.Horizontal> { Anchor(base, .centerX) }
    var centerY: Anchor<AnchorType.Center, AnchorAxis.Vertical> { Anchor(base, .centerY) }

    var firstBaseline: Anchor<AnchorType.Baseline, AnchorAxis.Vertical> { Anchor(base, .firstBaseline) }
    var lastBaseline: Anchor<AnchorType.Baseline, AnchorAxis.Vertical> { Anchor(base, .lastBaseline) }

    var width: Anchor<AnchorType.Dimension, AnchorAxis.Horizontal> { Anchor(base, .width) }
    var height: Anchor<AnchorType.Dimension, AnchorAxis.Vertical> { Anchor(base, .height) }

    // MARK: Anchor Collections

    var edges: AnchorCollectionEdges { AnchorCollectionEdges(item: base) }
    var center: AnchorCollectionCenter { AnchorCollectionCenter(x: centerX, y: centerY) }
    var size: AnchorCollectionSize { AnchorCollectionSize(width: width, height: height) }
}

#if os(iOS) || os(tvOS)
internal extension LayoutAnchors where Base: UIView {
    var margins: LayoutAnchors<UILayoutGuide> { base.layoutMarginsGuide.anchors }
    var safeArea: LayoutAnchors<UILayoutGuide> { base.safeAreaLayoutGuide.anchors }
}
#endif

// MARK: - Anchors

// phantom types
internal enum AnchorAxis {
    internal class Horizontal {}
    internal class Vertical {}
}

internal enum AnchorType {
    internal class Dimension {}
    internal class Alignment {}
    internal class Center: Alignment {}
    internal class Edge: Alignment {}
    internal class Baseline: Alignment {}
}

/// An anchor represents one of the view's layout attributes (e.g. `left`,
/// `centerX`, `width`, etc). Use the anchor’s methods to construct constraints.
internal struct Anchor<Type, Axis> { // type and axis are phantom types
    fileprivate let item: LayoutItem
    fileprivate let attribute: NSLayoutConstraint.Attribute
    fileprivate let offset: CGFloat
    fileprivate let multiplier: CGFloat

    fileprivate init(_ item: LayoutItem, _ attribute: NSLayoutConstraint.Attribute, offset: CGFloat = 0, multiplier: CGFloat = 1) {
        self.item = item; self.attribute = attribute; self.offset = offset; self.multiplier = multiplier
    }

    /// Returns a new anchor offset by a given amount.
    ///
    /// - note: Consider using a convenience operator instead: `view.anchors.top + 10`.
    internal func offsetting(by offset: CGFloat) -> Anchor<Type, Axis> {
        Anchor<Type, Axis>(item, attribute, offset: self.offset + offset, multiplier: self.multiplier)
    }

    /// Returns a new anchor with a given multiplier.
    ///
    /// - note: Consider using a convenience operator instead: `view.anchors.height * 2`.
    internal func multiplied(by multiplier: CGFloat) -> Anchor<Type, Axis> {
        Anchor<Type, Axis>(item, attribute, offset: self.offset * multiplier, multiplier: self.multiplier * multiplier)
    }
}

internal func + <Type, Axis>(anchor: Anchor<Type, Axis>, offset: CGFloat) -> Anchor<Type, Axis> {
    anchor.offsetting(by: offset)
}

internal func - <Type, Axis>(anchor: Anchor<Type, Axis>, offset: CGFloat) -> Anchor<Type, Axis> {
    anchor.offsetting(by: -offset)
}

internal func * <Type, Axis>(anchor: Anchor<Type, Axis>, multiplier: CGFloat) -> Anchor<Type, Axis> {
    anchor.multiplied(by: multiplier)
}

// MARK: - Anchors (AnchorType.Alignment)

internal extension Anchor where Type: AnchorType.Alignment {
    @discardableResult func equal<Type: AnchorType.Alignment>(_ anchor: Anchor<Type, Axis>, constant: CGFloat = 0) -> NSLayoutConstraint {
        Constraints.constrain(self, anchor, constant: constant, relation: .equal)
    }

    @discardableResult func greaterThanOrEqual<Type: AnchorType.Alignment>(_ anchor: Anchor<Type, Axis>, constant: CGFloat = 0) -> NSLayoutConstraint {
        Constraints.constrain(self, anchor, constant: constant, relation: .greaterThanOrEqual)
    }

    @discardableResult func lessThanOrEqual<Type: AnchorType.Alignment>(_ anchor: Anchor<Type, Axis>, constant: CGFloat = 0) -> NSLayoutConstraint {
        Constraints.constrain(self, anchor, constant: constant, relation: .lessThanOrEqual)
    }
}

// MARK: - Anchors (AnchorType.Dimension)

internal extension Anchor where Type: AnchorType.Dimension {
    @discardableResult func equal<Type: AnchorType.Dimension, Axis>(_ anchor: Anchor<Type, Axis>, constant: CGFloat = 0) -> NSLayoutConstraint {
        Constraints.constrain(self, anchor, constant: constant, relation: .equal)
    }

    @discardableResult func greaterThanOrEqual<Type: AnchorType.Dimension, Axis>(
        _ anchor: Anchor<Type, Axis>,
        constant: CGFloat = 0) -> NSLayoutConstraint {
        Constraints.constrain(self, anchor, constant: constant, relation: .greaterThanOrEqual)
    }

    @discardableResult func lessThanOrEqual<Type: AnchorType.Dimension, Axis>(_ anchor: Anchor<Type, Axis>, constant: CGFloat = 0) -> NSLayoutConstraint {
        Constraints.constrain(self, anchor, constant: constant, relation: .lessThanOrEqual)
    }
}

// MARK: - Anchors (AnchorType.Dimension)

extension Anchor where Type: AnchorType.Dimension {
    @discardableResult internal func equal(_ constant: CGFloat) -> NSLayoutConstraint {
        Constraints.constrain(item: item, attribute: attribute, relatedBy: .equal, constant: constant)
    }

    @discardableResult internal func greaterThanOrEqual(_ constant: CGFloat) -> NSLayoutConstraint {
        Constraints.constrain(item: item, attribute: attribute, relatedBy: .greaterThanOrEqual, constant: constant)
    }

    @discardableResult internal func lessThanOrEqual(_ constant: CGFloat) -> NSLayoutConstraint {
        Constraints.constrain(item: item, attribute: attribute, relatedBy: .lessThanOrEqual, constant: constant)
    }
}

// MARK: - Anchors (AnchorType.Edge)

extension Anchor where Type: AnchorType.Edge {
    /// Pins the edge to the respected edges of the given container.
    @discardableResult internal func pin(to container: LayoutItem? = nil, inset: CGFloat = 0) -> NSLayoutConstraint {
        let isInverted = [.trailing, .right, .bottom].contains(attribute)
        return Constraints.constrain(self, toItem: container ?? item.superview!, attribute: attribute, constant: (isInverted ? -inset : inset))
    }

    /// Adds spacing between the current anchors.
    @discardableResult internal func spacing<Type: AnchorType.Edge>(
        _ spacing: CGFloat,
        to anchor: Anchor<Type, Axis>,
        relation: NSLayoutConstraint.Relation = .equal) -> NSLayoutConstraint {
        let isInverted = (attribute == .bottom && anchor.attribute == .top) ||
            (attribute == .right && anchor.attribute == .left) ||
            (attribute == .trailing && anchor.attribute == .leading)
        return Constraints.constrain(self, anchor, constant: isInverted ? -spacing : spacing, relation: isInverted ? relation.inverted : relation)
    }
}

// MARK: - Anchors (AnchorType.Center)

extension Anchor where Type: AnchorType.Center {
    /// Aligns the axis with a superview axis.
    @discardableResult internal func align(offset: CGFloat = 0) -> NSLayoutConstraint {
        Constraints.constrain(self, toItem: item.superview!, attribute: attribute, constant: offset)
    }
}

// MARK: - AnchorCollectionEdges

internal struct Alignmment {
    internal enum Horizontal {
        case fill, center, leading, trailing
    }
    internal enum Vertical {
        case fill, center, top, bottom
    }

    internal let horizontal: Horizontal
    internal let vertical: Vertical

    internal init(horizontal: Horizontal, vertical: Vertical) {
        (self.horizontal, self.vertical) = (horizontal, vertical)
    }

    internal static let fill = Alignmment(horizontal: .fill, vertical: .fill)
    internal static let center = Alignmment(horizontal: .center, vertical: .center)
    internal static let topLeading = Alignmment(horizontal: .leading, vertical: .top)
    internal static let leading = Alignmment(horizontal: .leading, vertical: .fill)
    internal static let bottomLeading = Alignmment(horizontal: .leading, vertical: .bottom)
    internal static let bottom = Alignmment(horizontal: .fill, vertical: .bottom)
    internal static let bottomTrailing = Alignmment(horizontal: .trailing, vertical: .bottom)
    internal static let trailing = Alignmment(horizontal: .trailing, vertical: .fill)
    internal static let topTrailing = Alignmment(horizontal: .trailing, vertical: .top)
    internal static let top = Alignmment(horizontal: .fill, vertical: .top)
}

internal struct AnchorCollectionEdges {
    fileprivate let item: LayoutItem
    fileprivate var isAbsolute = false

    // By default, edges use locale-specific `.leading` and `.trailing`
    internal func absolute() -> AnchorCollectionEdges {
        AnchorCollectionEdges(item: item, isAbsolute: true)
    }

    #if os(iOS) || os(tvOS)
    internal typealias Axis = NSLayoutConstraint.Axis
    #else
    internal typealias Axis = NSLayoutConstraint.Orientation
    #endif

    @discardableResult internal func pin(
        to item2: LayoutItem? = nil,
        insets: EdgeInsets = .zero,
        axis: Axis? = nil,
        alignment: Alignmment = .fill) -> [NSLayoutConstraint] {
        let item2 = item2 ?? item.superview!
        let left: NSLayoutConstraint.Attribute = isAbsolute ? .left : .leading
        let right: NSLayoutConstraint.Attribute = isAbsolute ? .right : .trailing
        var constraints = [NSLayoutConstraint]()

        func constrain(attribute: NSLayoutConstraint.Attribute, relation: NSLayoutConstraint.Relation, constant: CGFloat) {
            constraints.append(Constraints.constrain(
                item: item,
                attribute: attribute,
                relatedBy: relation,
                toItem: item2,
                attribute: attribute,
                multiplier: 1,
                constant: constant))
        }

        if axis == nil || axis == .horizontal {
            constrain(
                attribute: left,
                relation: alignment.horizontal == .fill || alignment.horizontal == .leading ? .equal : .greaterThanOrEqual,
                constant: insets.left)
            constrain(
                attribute: right,
                relation: alignment.horizontal == .fill || alignment.horizontal == .trailing ? .equal : .lessThanOrEqual,
                constant: -insets.right)
            if alignment.horizontal == .center {
                constrain(attribute: .centerX, relation: .equal, constant: 0)
            }
        }
        if axis == nil || axis == .vertical {
            constrain(
                attribute: .top,
                relation: alignment.vertical == .fill || alignment.vertical == .top ? .equal : .greaterThanOrEqual,
                constant: insets.top)
            constrain(
                attribute: .bottom,
                relation: alignment.vertical == .fill || alignment.vertical == .bottom ? .equal : .lessThanOrEqual,
                constant: -insets.bottom)
            if alignment.vertical == .center {
                constrain(attribute: .centerY, relation: .equal, constant: 0)
            }
        }
        return constraints
    }
}

// MARK: - AnchorCollectionCenter

internal struct AnchorCollectionCenter {
    fileprivate let x: Anchor<AnchorType.Center, AnchorAxis.Horizontal>
    fileprivate let y: Anchor<AnchorType.Center, AnchorAxis.Vertical>

    /// Centers the view in the superview.
    @discardableResult internal func align() -> [NSLayoutConstraint] {
        [x.align(), y.align()]
    }

    /// Makes the axis equal to the other collection of axis.
    @discardableResult internal func align<Item: LayoutItem>(with item: Item) -> [NSLayoutConstraint] {
        [x.equal(item.anchors.centerX), y.equal(item.anchors.centerY)]
    }
}

// MARK: - AnchorCollectionSize

internal struct AnchorCollectionSize {
    fileprivate let width: Anchor<AnchorType.Dimension, AnchorAxis.Horizontal>
    fileprivate let height: Anchor<AnchorType.Dimension, AnchorAxis.Vertical>

    /// Set the size of item.
    @discardableResult internal func equal(_ size: CGSize) -> [NSLayoutConstraint] {
        [width.equal(size.width), height.equal(size.height)]
    }

    /// Set the size of item.
    @discardableResult internal func greaterThanOrEqul(_ size: CGSize) -> [NSLayoutConstraint] {
        [width.greaterThanOrEqual(size.width), height.greaterThanOrEqual(size.height)]
    }

    /// Set the size of item.
    @discardableResult internal func lessThanOrEqual(_ size: CGSize) -> [NSLayoutConstraint] {
        [width.lessThanOrEqual(size.width), height.lessThanOrEqual(size.height)]
    }

    /// Makes the size of the item equal to the size of the other item.
    @discardableResult internal func equal<Item: LayoutItem>(_ item: Item, insets: CGSize = .zero, multiplier: CGFloat = 1) -> [NSLayoutConstraint] {
        [width.equal(item.anchors.width * multiplier - insets.width), height.equal(item.anchors.height * multiplier - insets.height)]
    }

    @discardableResult internal func greaterThanOrEqual<Item: LayoutItem>(
        _ item: Item,
        insets: CGSize = .zero,
        multiplier: CGFloat = 1) -> [NSLayoutConstraint] {
        [width.greaterThanOrEqual(item.anchors.width * multiplier - insets.width),
         height.greaterThanOrEqual(item.anchors.height * multiplier - insets.height)]
    }

    @discardableResult internal func lessThanOrEqual<Item: LayoutItem>(
        _ item: Item,
        insets: CGSize = .zero,
        multiplier: CGFloat = 1) -> [NSLayoutConstraint] {
        [width.lessThanOrEqual(item.anchors.width * multiplier - insets.width),
         height.lessThanOrEqual(item.anchors.height * multiplier - insets.height)]
    }
}

// MARK: - Constraints

internal final class Constraints {
    /// Returns all of the created constraints.
    internal private(set) var constraints = [NSLayoutConstraint]()

    /// All of the constraints created in the given closure are automatically
    /// activated at the same time. This is more efficient then installing them
    /// one-be-one. More importantly, it allows to make changes to the constraints
    /// before they are installed (e.g. change `priority`).
    ///
    /// - parameter activate: Set to `false` to disable automatic activation of
    /// constraints.
    @discardableResult internal init(activate: Bool = true, _ closure: () -> Void) {
        Constraints._stack.append(self)
        closure() // create constraints
        Constraints._stack.removeLast()
        if activate { NSLayoutConstraint.activate(constraints) }
    }

    /// Creates and automatically installs a constraint.
    fileprivate static func constrain(
        item item1: Any,
        attribute attr1: NSLayoutConstraint.Attribute,
        relatedBy relation: NSLayoutConstraint.Relation = .equal,
        toItem item2: Any? = nil,
        attribute attr2: NSLayoutConstraint.Attribute? = nil,
        multiplier: CGFloat = 1,
        constant: CGFloat = 0) -> NSLayoutConstraint {
            
        precondition(Thread.isMainThread, "Align APIs can only be used from the main thread")
        #if os(iOS) || os(tvOS)
        (item1 as? UIView)?.translatesAutoresizingMaskIntoConstraints = false
        #elseif os(macOS)
        (item1 as? NSView)?.translatesAutoresizingMaskIntoConstraints = false
        #endif
        let constraint = NSLayoutConstraint(
            item: item1,
            attribute: attr1,
            relatedBy: relation,
            toItem: item2,
            attribute: attr2 ?? .notAnAttribute,
            multiplier: multiplier,
            constant: constant)
        _install(constraint)
        return constraint
    }

    /// Creates and automatically installs a constraint between two anchors.
    fileprivate static func constrain<T1, A1, T2, A2>(
        _ lhs: Anchor<T1, A1>,
        _ rhs: Anchor<T2, A2>,
        constant: CGFloat = 0,
        multiplier: CGFloat = 1,
        relation: NSLayoutConstraint.Relation = .equal) -> NSLayoutConstraint {
        constrain(
            item: lhs.item,
            attribute: lhs.attribute,
            relatedBy: relation,
            toItem: rhs.item,
            attribute: rhs.attribute,
            multiplier: (multiplier / lhs.multiplier) * rhs.multiplier,
            constant: constant - lhs.offset + rhs.offset)
    }

    /// Creates and automatically installs a constraint between an anchor and
    /// a given item.
    fileprivate static func constrain<T1, A1>(
        _ lhs: Anchor<T1, A1>,
        toItem item2: Any?,
        attribute attr2: NSLayoutConstraint.Attribute?,
        constant: CGFloat = 0,
        multiplier: CGFloat = 1,
        relation: NSLayoutConstraint.Relation = .equal) -> NSLayoutConstraint {
        constrain(
            item: lhs.item,
            attribute: lhs.attribute,
            relatedBy: relation,
            toItem: item2,
            attribute: attr2,
            multiplier: multiplier / lhs.multiplier,
            constant: constant - lhs.offset)
    }

    private static var _stack = [Constraints]() // this is what enabled constraint auto-installing

    private static func _install(_ constraint: NSLayoutConstraint) {
        if let group = _stack.last {
            group.constraints.append(constraint)
        } else {
            constraint.isActive = true
        }
    }
}

extension Constraints {
    @discardableResult internal convenience init<A: LayoutItem>(for a: A, _ closure: (LayoutAnchors<A>) -> Void) {
        self.init { closure(a.anchors) }
    }

    @discardableResult internal convenience init<A: LayoutItem, B: LayoutItem>(for a: A, _ b: B, _ closure: (LayoutAnchors<A>, LayoutAnchors<B>) -> Void) {
        self.init { closure(a.anchors, b.anchors) }
    }

    @discardableResult internal convenience init<A: LayoutItem, B: LayoutItem, C: LayoutItem>(
        for a: A,
        _ b: B,
        _ c: C,
        _ closure: (LayoutAnchors<A>, LayoutAnchors<B>, LayoutAnchors<C>) -> Void) {
        self.init { closure(a.anchors, b.anchors, c.anchors) }
    }

    @discardableResult internal convenience init<A: LayoutItem, B: LayoutItem, C: LayoutItem, D: LayoutItem>(
        for a: A,
        _ b: B,
        _ c: C,
        _ d: D,
        _ closure: (LayoutAnchors<A>, LayoutAnchors<B>, LayoutAnchors<C>, LayoutAnchors<D>) -> Void) {
        self.init { closure(a.anchors, b.anchors, c.anchors, d.anchors) }
    }
}

// MARK: - Misc

#if os(iOS) || os(tvOS)
internal typealias EdgeInsets = UIEdgeInsets
#elseif os(macOS)
internal typealias EdgeInsets = NSEdgeInsets

internal extension NSEdgeInsets {
    static let zero = NSEdgeInsets(top: 0, left: 0, bottom: 0, right: 0)
}
#endif

extension NSLayoutConstraint.Relation {
    fileprivate var inverted: NSLayoutConstraint.Relation {
        switch self {
        case .greaterThanOrEqual: return .lessThanOrEqual
        case .lessThanOrEqual: return .greaterThanOrEqual
        case .equal: return self
        @unknown default: return self
        }
    }
}

extension EdgeInsets {
    fileprivate func inset(for attribute: NSLayoutConstraint.Attribute, edge: Bool = false) -> CGFloat {
        switch attribute {
        case .top:
            return top
        case .bottom:
            return edge ? -bottom : bottom
        case .left, .leading:
            return left
        case .right, .trailing:
            return edge ? -right : right
        default:
            return 0
        }
    }
}

// MARK: - Extensions

extension Anchor where Type: AnchorType.Edge {
    @discardableResult internal func safeAreaPin(inset: CGFloat = 0) -> NSLayoutConstraint {
        pin(to: item.superview!.safeAreaLayoutGuide, inset: inset)
    }
    
    @discardableResult internal func readableContentPin(inset: CGFloat = 0) -> NSLayoutConstraint {
        pin(to: item.superview!.readableContentGuide, inset: inset)
    }
    
    @discardableResult internal func marginsPin(inset: CGFloat = 0) -> NSLayoutConstraint {
        pin(to: item.superview!.layoutMarginsGuide, inset: inset)
    }
}

extension AnchorCollectionEdges {
    @discardableResult internal func safeAreaPin(insets: EdgeInsets = .zero, axis: Axis? = nil, alignment: Alignmment = .fill) -> [NSLayoutConstraint] {
        pin(to: item.superview!.safeAreaLayoutGuide, insets: insets, axis: axis, alignment: alignment)
    }
    
    @discardableResult internal func readableContentPin(
        insets: EdgeInsets = .zero,
        axis: Axis? = nil,
        alignment: Alignmment = .fill) -> [NSLayoutConstraint] {
        pin(to: item.superview!.readableContentGuide, insets: insets, axis: axis, alignment: alignment)
    }
    
    @discardableResult internal func marginsPin(
        insets: EdgeInsets = .zero,
        axis: Axis? = nil,
        alignment: Alignmment = .fill) -> [NSLayoutConstraint] {
        pin(to: item.superview!.layoutMarginsGuide, insets: insets, axis: axis, alignment: alignment)
    }
}