//
// Copyright 2021 Signal Messenger, LLC
// SPDX-License-Identifier: AGPL-3.0-only
//

import Foundation
import SignalServiceKit

// ManualStackView (like ManualLayoutView) uses a CATransformLayer
// by default.  CATransformLayer does not render.
//
// If you need to use properties like backgroundColor, border,
// masksToBounds, shadow, etc. you should use this subclass instead.
//
// See: https://developer.apple.com/documentation/quartzcore/catransformlayer
open class ManualStackViewWithLayer: ManualStackView {
    override open class var layerClass: AnyClass {
        CALayer.self
    }
}

// MARK: -

open class ManualStackView: ManualLayoutView {

    public typealias Measurement = ManualStackMeasurement

    private var arrangedSubviews = [UIView]()

    public var measurement: Measurement?

    public init(name: String, arrangedSubviews: [UIView] = []) {
        super.init(name: name)

        addArrangedSubviews(arrangedSubviews)
    }

    // MARK: - Config

    public var axis: NSLayoutConstraint.Axis = .horizontal
    public var alignment: UIStackView.Alignment = .center
    public var spacing: CGFloat = 0

    public typealias Config = OWSStackView.Config

    public func apply(config: Config) {
        if self.axis != config.axis {
            self.axis = config.axis
        }
        if self.alignment != config.alignment {
            self.alignment = config.alignment
        }
        if self.spacing != config.spacing {
            self.spacing = config.spacing
        }
        if self.layoutMargins != config.layoutMargins {
            self.layoutMargins = config.layoutMargins
        }
    }

    public var asConfig: Config {
        Config(
            axis: self.axis,
            alignment: self.alignment,
            spacing: self.spacing,
            layoutMargins: self.layoutMargins,
        )
    }

    // MARK: - Arrangement

    private struct ArrangementItem {
        let subview: UIView
        let frame: CGRect

        init(subview: UIView, frame: CGRect) {
            self.subview = subview
            self.frame = frame
        }

        func apply() {
            if subview.frame != frame {
                ManualLayoutView.setSubviewFrame(subview: subview, frame: frame)
            }
        }
    }

    private struct Arrangement {
        let items: [ArrangementItem]

        func apply() {
            for item in items {
                item.apply()
            }
        }
    }

    // We cache the resolved layout of the subviews.
    private var arrangement: Arrangement? {
        didSet {
            if arrangement != nil {
                invalidateIntrinsicContentSize()
                setNeedsLayout()
            }
        }
    }

    override func viewSizeDidChange() {
        invalidateArrangement()

        super.viewSizeDidChange()
    }

    public func invalidateArrangement() {
        arrangement = nil
    }

    override public func sizeThatFits(_ size: CGSize) -> CGSize {
        guard !isHidden else {
            return .zero
        }
        guard let measurement else {
            return super.sizeThatFits(size)
        }
        return measurement.measuredSize
    }

    override public func addSubview(_ view: UIView) {
        owsAssertDebug(!subviews.contains(view))
        super.addSubview(view)
        invalidateArrangement()
    }

    // NOTE: This method does _NOT_ call the superclass implementation.
    public func addArrangedSubview(_ view: UIView) {
        addSubview(view)
        owsAssertDebug(!arrangedSubviews.contains(view))

        view.translatesAutoresizingMaskIntoConstraints = false

        arrangedSubviews.append(view)
    }

    func addArrangedSubviews(_ subviews: [UIView], reverseOrder: Bool = false) {
        var subviews = subviews
        if reverseOrder {
            subviews.reverse()
        }
        for subview in subviews {
            addArrangedSubview(subview)
        }
    }

    override public func willRemoveSubview(_ view: UIView) {
        arrangedSubviews = self.arrangedSubviews.filter { view != $0 }
        super.willRemoveSubview(view)
        invalidateArrangement()
    }

    public func removeArrangedSubview(_ view: UIView) {
        view.removeFromSuperview()

        arrangedSubviews = arrangedSubviews.filter { $0 != view }
    }

    override public func layoutSubviews() {
        AssertIsOnMainThread()

        // We apply the layout blocks _after_ the arrangement.
        super.layoutSubviews(skipLayoutBlocks: true)

        guard bounds.width > 0, bounds.height > 0 else {
            for subview in subviews {
                subview.frame = .zero
            }
            return
        }

        ensureArrangement()?.apply()

        applyLayoutBlocks()
    }

    public func configure(
        config: Config,
        measurement: Measurement,
        subviews: [UIView],
    ) {
        owsAssertDebug(self.measurement == nil)

        apply(config: config)
        self.measurement = measurement
        for subview in subviews {
            addArrangedSubview(subview)
        }

        invalidateArrangement()
    }

    public func configureForReuse(config: Config, measurement: Measurement) {
        apply(config: config)
        self.measurement = measurement

        invalidateArrangement()

        layoutSubviews()
    }

    private func ensureArrangement() -> Arrangement? {
        if let arrangement {
            return arrangement
        }
        guard let measurement else {
            owsFailDebug("\(name): Missing measurement.")
            return nil
        }
        // Ignore hidden subviews.
        let arrangedSubviews = self.arrangedSubviews.filter { !$0.isHidden }
        if arrangedSubviews.count > measurement.subviewInfos.count {
            owsFailDebug("\(name): arrangedSubviews: \(arrangedSubviews.count) != subviewInfos: \(measurement.subviewInfos.count)")
        }
        let isHorizontal = axis == .horizontal
        let count = min(arrangedSubviews.count, measurement.subviewInfos.count)
        // Build the list of subviews to layout and find their layout info.
        var layoutItems = [LayoutItem]()
        for index in 0..<count {
            guard let subview = arrangedSubviews[safe: index] else {
                owsFailDebug("\(name): Missing subview.")
                break
            }
            guard let subviewInfo = measurement.subviewInfos[safe: index] else {
                owsFailDebug("\(name): Missing measuredSize.")
                break
            }
            owsAssertDebug(!subview.isHidden)
            layoutItems.append(LayoutItem(
                subview: subview,
                subviewInfo: subviewInfo,
                isHorizontal: isHorizontal,
            ))
        }
        return buildArrangement(measurement: measurement, layoutItems: layoutItems)
    }

    // An alignment enum that can be used whether the layout axis
    // is horizontal or vertical.
    private enum OffAxisAlignment: CustomStringConvertible {
        case minimum
        case center
        case maximum
        case fill

        var description: String {
            switch self {
            case .minimum:
                return ".minimum"
            case .center:
                return ".center"
            case .maximum:
                return ".maximum"
            case .fill:
                return ".fill"
            }
        }
    }

    private func buildArrangement(
        measurement: Measurement,
        layoutItems: [LayoutItem],
    ) -> Arrangement {

        guard !layoutItems.isEmpty else {
            return Arrangement(items: [])
        }

        let isRTL: Bool
        switch semanticContentAttribute {
        case .forceLeftToRight, .spatial, .playback:
            isRTL = false
        case .forceRightToLeft:
            isRTL = true
        case .unspecified:
            isRTL = CurrentAppContext().isRTL
        @unknown default:
            isRTL = CurrentAppContext().isRTL
        }

        let isHorizontal = axis == .horizontal

        // If we're horizontal *and* RTL, we want to reverse the order
        // of the layout items so they layout from RTL instead of LTR.
        var layoutItems = layoutItems
        if isRTL, isHorizontal { layoutItems = layoutItems.reversed() }

        let layoutMargins = self.layoutMargins
        let layoutSize = (bounds.size - layoutMargins.totalSize).max(.zero)

        let onAxisMaxSize: CGFloat
        let offAxisMaxSize: CGFloat
        var offAxisAlignment: OffAxisAlignment
        if isHorizontal {
            onAxisMaxSize = layoutSize.width
            offAxisMaxSize = layoutSize.height

            switch alignment {
            case .top:
                offAxisAlignment = .minimum
            case .center:
                offAxisAlignment = .center
            case .bottom:
                offAxisAlignment = .maximum
            case .fill:
                offAxisAlignment = .fill
            default:
                owsFailDebug("\(name): Invalid alignment: \(alignment.rawValue).")
                offAxisAlignment = .center
            }
        } else {
            onAxisMaxSize = layoutSize.height
            offAxisMaxSize = layoutSize.width

            switch alignment {
            case .leading:
                offAxisAlignment = isRTL ? .maximum : .minimum
            case .center:
                offAxisAlignment = .center
            case .trailing:
                offAxisAlignment = isRTL ? .minimum : .maximum
            case .fill:
                offAxisAlignment = .fill
            default:
                owsFailDebug("Invalid alignment: \(alignment.rawValue).")
                offAxisAlignment = .center
            }
        }

        // Initialize onAxisLocation.
        var onAxisSizeTotal: CGFloat = 0
        for (index, layoutItem) in layoutItems.enumerated() {
            if index > 0 {
                onAxisSizeTotal += spacing
            }
            layoutItem.onAxisSize = layoutItem.onAxisMeasuredSize
            onAxisSizeTotal += layoutItem.onAxisMeasuredSize
        }

        // Handle underflow and overflow.
        //
        // If a stack's contents do not fit within the stack's bounds, they "overflow".
        // If a stack's contents are smaller than the stack's bounds, they "underflow".
        let fuzzyTolerance: CGFloat = 0.001
        if abs(onAxisSizeTotal - onAxisMaxSize) < fuzzyTolerance {
            // Exact match; no adjustments necessary.
        } else if onAxisSizeTotal < onAxisMaxSize {
            // Underflow case
            //
            // Underflow is expected; a stack view is often larger than
            // the minimum size of its contents.  The stack view will
            // expand the layout of its contents to take advantage of
            // the extra space.
            let underflow = onAxisMaxSize - onAxisSizeTotal

            // TODO: We could weight re-distribution by contentHuggingPriority.
            var underflowLayoutItems = layoutItems.filter {
                $0.subviewInfo.canExpandOnAxis(isHorizontalLayout: isHorizontal)
            }
            if underflowLayoutItems.isEmpty {
                owsFailDebug("\(name): No underflowLayoutItems.")
                underflowLayoutItems = layoutItems
            }

            let adjustment = underflow / CGFloat(underflowLayoutItems.count)
            for layoutItem in underflowLayoutItems {
                layoutItem.onAxisSize = max(0, layoutItem.onAxisSize + adjustment)
            }
        } else if onAxisSizeTotal > onAxisMaxSize {
            // Overflow case
            //
            // Overflow should be rare, at least in the conversation view cells.
            // It is expected in some cases, e.g. when animating an orientation
            // change when the new layout hasn't landed yet.
            let overflow = onAxisSizeTotal - onAxisMaxSize

            // TODO: We could weight re-distribution by compressionResistence.
            var overflowLayoutItems = layoutItems.filter {
                $0.subviewInfo.canCompressOnAxis(isHorizontalLayout: isHorizontal)
            }
            if overflowLayoutItems.isEmpty {
                overflowLayoutItems = layoutItems
            }

            let adjustment = overflow / CGFloat(overflowLayoutItems.count)
            for layoutItem in overflowLayoutItems {
                layoutItem.onAxisSize = max(0, layoutItem.onAxisSize - adjustment)
            }
        }

        // Determine onAxisLocation.
        var onAxisLocation: CGFloat = 0
        for layoutItem in layoutItems {
            layoutItem.onAxisLocation = onAxisLocation
            onAxisLocation += layoutItem.onAxisSize + spacing
        }

        // Determine offAxisSize and offAxisLocation.
        for layoutItem in layoutItems {
            var offAxisSize: CGFloat = min(layoutItem.offAxisMeasuredSize, offAxisMaxSize)
            if
                offAxisAlignment == .fill,
                layoutItem.subviewInfo.canExpandOffAxis(isHorizontalLayout: isHorizontal)
            {
                offAxisSize = offAxisMaxSize
            }
            layoutItem.offAxisSize = offAxisSize

            switch offAxisAlignment {
            case .minimum:
                layoutItem.offAxisLocation = 0
            case .maximum:
                layoutItem.offAxisLocation = offAxisMaxSize - offAxisSize
            case .center, .fill:
                layoutItem.offAxisLocation = (offAxisMaxSize - offAxisSize) * 0.5
            }
        }

        // Apply layoutMargins and locationOffset.
        for layoutItem in layoutItems {
            layoutItem.frame.x += layoutMargins.left + layoutItem.subviewInfo.locationOffset.x
            layoutItem.frame.y += layoutMargins.top + layoutItem.subviewInfo.locationOffset.y
        }

        let arrangementItems = layoutItems.map { $0.asArrangementItem }
        return Arrangement(items: arrangementItems)
    }

    private class LayoutItem {
        let subview: UIView
        let subviewInfo: ManualStackSubviewInfo
        let isHorizontal: Bool
        var frame: CGRect = .zero

        var measuredSize: CGSize { subviewInfo.measuredSize }

        var onAxisMeasuredSize: CGFloat {
            if isHorizontal {
                return measuredSize.width
            } else {
                return measuredSize.height
            }
        }

        var offAxisMeasuredSize: CGFloat {
            if isHorizontal {
                return measuredSize.height
            } else {
                return measuredSize.width
            }
        }

        var onAxisSize: CGFloat {
            get {
                if isHorizontal {
                    return frame.width
                } else {
                    return frame.height
                }
            }
            set {
                if isHorizontal {
                    frame.width = newValue
                } else {
                    frame.height = newValue
                }
            }
        }

        var offAxisSize: CGFloat {
            get {
                if isHorizontal {
                    return frame.height
                } else {
                    return frame.width
                }
            }
            set {
                if isHorizontal {
                    frame.height = newValue
                } else {
                    frame.width = newValue
                }
            }
        }

        var onAxisLocation: CGFloat {
            get {
                if isHorizontal {
                    return frame.x
                } else {
                    return frame.y
                }
            }
            set {
                if isHorizontal {
                    frame.x = newValue
                } else {
                    frame.y = newValue
                }
            }
        }

        var offAxisLocation: CGFloat {
            get {
                if isHorizontal {
                    return frame.y
                } else {
                    return frame.x
                }
            }
            set {
                if isHorizontal {
                    frame.y = newValue
                } else {
                    frame.x = newValue
                }
            }
        }

        init(
            subview: UIView,
            subviewInfo: ManualStackSubviewInfo,
            isHorizontal: Bool,
        ) {

            self.subview = subview
            self.subviewInfo = subviewInfo
            self.isHorizontal = isHorizontal
        }

        var asArrangementItem: ArrangementItem {
            ArrangementItem(subview: subview, frame: frame)
        }
    }

    public static func measure(
        config: Config,
        subviewInfos: [ManualStackSubviewInfo],
        verboseLogging: Bool = false,
    ) -> Measurement {

        let subviewSizes = subviewInfos.map { $0.measuredSize.max(.zero) }

        let spacingCount = max(0, subviewSizes.count - 1)

        var size = CGSize.zero
        switch config.axis {
        case .horizontal:
            size.width = subviewSizes.map { $0.width }.reduce(0, +)
            size.height = subviewSizes.map { $0.height }.reduce(0, max)
            size.width += CGFloat(spacingCount) * config.spacing
        case .vertical:
            size.width = subviewSizes.map { $0.width }.reduce(0, max)
            size.height = subviewSizes.map { $0.height }.reduce(0, +)
            size.height += CGFloat(spacingCount) * config.spacing
        @unknown default:
            owsFailDebug("Unknown axis: \(config.axis)")
        }

        size.width += config.layoutMargins.totalWidth
        size.height += config.layoutMargins.totalHeight
        size = size.ceil

        return Measurement(measuredSize: size, subviewInfos: subviewInfos)
    }

    override open func reset() {
        AssertIsOnMainThread()

        super.reset()

        alignment = .fill
        axis = .vertical
        spacing = 0

        self.measurement = nil
    }
}

// MARK: -

//// TODO: Can this be moved to UIView+OWS.swift?
private extension CGRect {

    var width: CGFloat {
        get {
            size.width
        }
        set {
            size.width = newValue
        }
    }

    var height: CGFloat {
        get {
            size.height
        }
        set {
            size.height = newValue
        }
    }
}

// MARK: -

// Analogous to UIView.compressionResistence and .contentHugging.
//
// If a stack's contents do not fit within the stack's bounds, they "overflow".
// If a stack's contents are smaller than the stack's bounds, they "underflow".
public enum ManualFlowBehavior {
    case fixed
    case canExpand
    case canCompress
    case canExpandAndCompress

    var canExpand: Bool {
        switch self {
        case .fixed, .canCompress:
            return false
        case .canExpand, .canExpandAndCompress:
            return true
        }
    }

    var canCompress: Bool {
        switch self {
        case .fixed, .canExpand:
            return false
        case .canCompress, .canExpandAndCompress:
            return true
        }
    }
}

// MARK: -

public struct ManualStackSubviewInfo: Equatable {
    let measuredSize: CGSize

    let horizontalFlowBehavior: ManualFlowBehavior
    let verticalFlowBehavior: ManualFlowBehavior

    let locationOffset: CGPoint

    public init(
        measuredSize: CGSize,
        horizontalFlowBehavior: ManualFlowBehavior,
        verticalFlowBehavior: ManualFlowBehavior,
        locationOffset: CGPoint = .zero,
    ) {
        self.measuredSize = measuredSize
        self.horizontalFlowBehavior = horizontalFlowBehavior
        self.verticalFlowBehavior = verticalFlowBehavior
        self.locationOffset = locationOffset
    }

    public init(
        measuredSize: CGSize,
        hasFixedWidth: Bool = false,
        hasFixedHeight: Bool = false,
        locationOffset: CGPoint = .zero,
    ) {
        self.measuredSize = measuredSize
        self.horizontalFlowBehavior = hasFixedWidth ? .fixed : .canExpandAndCompress
        self.verticalFlowBehavior = hasFixedHeight ? .fixed : .canExpandAndCompress
        self.locationOffset = locationOffset
    }

    public init(
        measuredSize: CGSize,
        hasFixedSize: Bool,
        locationOffset: CGPoint = .zero,
    ) {
        self.measuredSize = measuredSize
        self.horizontalFlowBehavior = hasFixedSize ? .fixed : .canExpandAndCompress
        self.verticalFlowBehavior = hasFixedSize ? .fixed : .canExpandAndCompress
        self.locationOffset = locationOffset
    }

    public init(measuredSize: CGSize, subview: UIView) {
        self.measuredSize = measuredSize

        let hasFixedWidth = subview.contentHuggingPriority(for: .horizontal) != .defaultHigh
        let hasFixedHeight = subview.contentHuggingPriority(for: .vertical) != .defaultHigh
        self.horizontalFlowBehavior = hasFixedWidth ? .fixed : .canExpandAndCompress
        self.verticalFlowBehavior = hasFixedHeight ? .fixed : .canExpandAndCompress

        self.locationOffset = .zero
    }

    private static func setSubviewFrame(subview: UIView, frame: CGRect) {
        guard subview.frame != frame else {
            return
        }
        subview.frame = frame
    }

    public static var empty: ManualStackSubviewInfo {
        ManualStackSubviewInfo(measuredSize: .zero)
    }

    func canExpandOnAxis(isHorizontalLayout: Bool) -> Bool {
        (isHorizontalLayout ? horizontalFlowBehavior : verticalFlowBehavior).canExpand
    }

    func canCompressOnAxis(isHorizontalLayout: Bool) -> Bool {
        (isHorizontalLayout ? horizontalFlowBehavior : verticalFlowBehavior).canCompress
    }

    func canExpandOffAxis(isHorizontalLayout: Bool) -> Bool {
        (isHorizontalLayout ? verticalFlowBehavior : horizontalFlowBehavior).canExpand
    }

    func canCompressOffAxis(isHorizontalLayout: Bool) -> Bool {
        (isHorizontalLayout ? verticalFlowBehavior : horizontalFlowBehavior).canCompress
    }
}

// MARK: -

public extension CGSize {
    var asManualSubviewInfo: ManualStackSubviewInfo {
        ManualStackSubviewInfo(measuredSize: self)
    }

    func asManualSubviewInfo(
        hasFixedWidth: Bool = false,
        hasFixedHeight: Bool = false,
        locationOffset: CGPoint = .zero,
    ) -> ManualStackSubviewInfo {
        ManualStackSubviewInfo(
            measuredSize: self,
            hasFixedWidth: hasFixedWidth,
            hasFixedHeight: hasFixedHeight,
            locationOffset: locationOffset,
        )
    }

    func asManualSubviewInfo(
        hasFixedSize: Bool,
        locationOffset: CGPoint = .zero,
    ) -> ManualStackSubviewInfo {
        ManualStackSubviewInfo(
            measuredSize: self,
            hasFixedSize: hasFixedSize,
            locationOffset: locationOffset,
        )
    }

    func asManualSubviewInfo(
        horizontalFlowBehavior: ManualFlowBehavior,
        verticalFlowBehavior: ManualFlowBehavior,
        locationOffset: CGPoint = .zero,
    ) -> ManualStackSubviewInfo {
        ManualStackSubviewInfo(
            measuredSize: self,
            horizontalFlowBehavior: horizontalFlowBehavior,
            verticalFlowBehavior: verticalFlowBehavior,
            locationOffset: locationOffset,
        )
    }
}

// MARK: -

public struct ManualStackMeasurement: Equatable {
    public let measuredSize: CGSize

    fileprivate let subviewInfos: [ManualStackSubviewInfo]

    init(measuredSize: CGSize, subviewInfos: [ManualStackSubviewInfo]) {
        self.measuredSize = measuredSize
        self.subviewInfos = subviewInfos
    }

    fileprivate var subviewMeasuredSizes: [CGSize] {
        subviewInfos.map { $0.measuredSize }
    }

    public static func build(measuredSize: CGSize) -> ManualStackMeasurement {
        ManualStackMeasurement(measuredSize: measuredSize, subviewInfos: [])
    }
}

// MARK: -

public extension ManualStackView {
    @discardableResult
    func configure(
        config: Config,
        subviews: [UIView],
        subviewInfos: [ManualStackSubviewInfo],
    ) -> Measurement {
        let measurement = ManualStackView.measure(config: config, subviewInfos: subviewInfos)
        self.configure(config: config, measurement: measurement, subviews: subviews)
        return measurement
    }
}