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

import SignalServiceKit

open class InteractiveSheetViewController: OWSViewController {

    public enum Constants {
        public static let handleSize = CGSize(width: 52, height: 5)
        public static let handleInsideMargin: CGFloat = 12
        public static let handleHeight = 2 * handleInsideMargin + handleSize.height

        /// Max height of the sheet has its top this far from the safe area top of the screen.
        fileprivate static let extraTopPadding: CGFloat = 32

        public static let defaultMinHeight: CGFloat = 346

        /// Any absolute velocity below this amount counts as zero velocity, e.g. just releasing.
        fileprivate static let baseVelocityThreshold: CGFloat = 200
        /// Any upwards velocity greater this that amount maximizes the sheet.
        fileprivate static let maximizeVelocityThreshold: CGFloat = 500
        /// Any downwards velocity greater than this amount dismisses the sheet.
        fileprivate static let dismissVelocityThreshold: CGFloat = 1000
    }

    public var topCornerRadius: CGFloat = 16 {
        didSet {
            sheetContainerView.layer.cornerRadius = topCornerRadius
        }
    }

    private lazy var sheetContainerView: UIView = {
        let view: UIView
        if let visualEffect {
            view = UIVisualEffectView(effect: visualEffect)
        } else {
            view = UIView()
        }
        view.layer.cornerRadius = topCornerRadius
        view.layer.maskedCorners = [.layerMinXMinYCorner, .layerMaxXMinYCorner]
        view.layer.masksToBounds = true
        view.preservesSuperviewLayoutMargins = true
        return view
    }()

    private var sheetContainerContentView: UIView {
        return (sheetContainerView as? UIVisualEffectView)?.contentView ?? sheetContainerView
    }

    private let sheetStackView: UIStackView = {
        let view = UIStackView()
        view.axis = .vertical
        view.preservesSuperviewLayoutMargins = true
        return view
    }()

    public let contentView = UIView()

    open var interactiveScrollViews: [UIScrollView] { [] }

    open var dismissesWithHighVelocitySwipe: Bool { false }
    open var shrinksWithHighVelocitySwipe: Bool { true }
    open var canBeDismissed: Bool { true }
    /// Allows taps above the sheet to pass through to the parent.
    open var canInteractWithParent: Bool { false }

    open var sheetBackgroundColor: UIColor { Theme.actionSheetBackgroundColor }
    open var handleBackgroundColor: UIColor { UIColor.Signal.primaryFill }

    /// Override to `true` to make the content appear on a glass background on
    /// iOS 26 and later. `sheetBackgroundColor` will be ignored when on glass,
    /// but still be sure to set it for devices running iOS 18 and older.
    open var placeOnGlassIfAvailable: Bool { false }
    private var isOnGlass: Bool {
        if #available(iOS 26, *) {
            placeOnGlassIfAvailable
        } else {
            false
        }
    }

    public weak var externalBackdropView: UIView?
    private lazy var _internalBackdropView = UIView()
    public var backdropView: UIView? { externalBackdropView ?? _internalBackdropView }
    public var backdropColor = UIColor.Signal.backdrop

    public var maxWidth: CGFloat { 512 }

    private let handle = UIView()
    private lazy var handleContainer = UIView()

    private let visualEffect: UIVisualEffect?

    public weak var sheetPanDelegate: SheetPanDelegate?
    public weak var dismissalDelegate: (any SheetDismissalDelegate)?

    public init(visualEffect: UIVisualEffect? = nil) {
        self.visualEffect = visualEffect
        super.init()
        modalPresentationStyle = .custom
        transitioningDelegate = self
    }

    open func willDismissInteractively() {}

    // MARK: -

    public class SheetView: UIView {
        weak var interactiveSheetViewController: InteractiveSheetViewController?

        private let canInteractWithParent: Bool

        init(
            canInteractWithParent: Bool,
            interactiveSheetViewController: InteractiveSheetViewController,
        ) {
            self.canInteractWithParent = canInteractWithParent
            self.interactiveSheetViewController = interactiveSheetViewController
            super.init(frame: .zero)
        }

        override public func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
            guard self.canInteractWithParent else {
                return super.hitTest(point, with: event)
            }

            guard
                let interactiveSheetViewController,
                let presentingView = interactiveSheetViewController.presentingViewController?.view
            else {
                owsFailDebug("A parent view controller is missing")
                return super.hitTest(point, with: event)
            }

            let sheetContent = interactiveSheetViewController.sheetContainerView
            let pointInSheet = self.convert(point, to: sheetContent)
            if sheetContent.bounds.contains(pointInSheet) {
                // Hit in sheet
                return super.hitTest(point, with: event)
            }

            // Hit in parent
            return presentingView.hitTest(point, with: event)
        }

        required init?(coder: NSCoder) {
            fatalError("init(coder:) has not been implemented")
        }
    }

    private var maxWidthConstraint: NSLayoutConstraint?
    override open func viewWillTransition(to size: CGSize, with coordinator: any UIViewControllerTransitionCoordinator) {
        super.viewWillTransition(to: size, with: coordinator)

        maxWidthConstraint?.autoRemove()
        let minScreenDimension = min(CurrentAppContext().frame.width, CurrentAppContext().frame.height)
        if minScreenDimension <= maxWidth {
            maxWidthConstraint = sheetContainerView.autoSetDimension(.width, toSize: minScreenDimension)
        }
    }

    override public func loadView() {
        let sheetView = SheetView(
            canInteractWithParent: self.canInteractWithParent,
            interactiveSheetViewController: self,
        )
        view = sheetView
        view.backgroundColor = .clear

        view.addSubview(sheetContainerView)
        sheetCurrentOffsetConstraint = sheetContainerView.autoPinEdge(toSuperviewEdge: .bottom)
        sheetContainerView.autoHCenterInSuperview()

        let margin: CGFloat = isOnGlass ? 8 : 0

        // Prefer to be full width, but don't exceed the maximum width
        sheetContainerView.autoSetDimension(.width, toSize: maxWidth, relation: .lessThanOrEqual)
        sheetContainerView.autoPinWidthToSuperview(relation: .lessThanOrEqual)

        NSLayoutConstraint.autoSetPriority(.defaultHigh) {
            sheetContainerView.autoPinWidthToSuperview()
        }

        sheetContainerContentView.addSubview(sheetStackView)
        sheetStackView.autoPinEdgesToSuperviewEdges(with: .init(
            top: 0,
            left: margin,
            bottom: margin,
            right: margin,
        ))

        contentView.preservesSuperviewLayoutMargins = true
        sheetStackView.addArrangedSubview(contentView)
        contentView.autoPinWidthToSuperview()

        handle.autoSetDimensions(to: Constants.handleSize)
        handle.layer.cornerRadius = Constants.handleSize.height / 2
        sheetStackView.insertArrangedSubview(handleContainer, at: 0)
        handleContainer.autoPinWidthToSuperview()
        handleContainer.addSubview(handle)
        handle.backgroundColor = handleBackgroundColor
        handle.autoPinHeightToSuperview(withMargin: Constants.handleInsideMargin)
        handle.autoHCenterInSuperview()

        // Support tapping the backdrop to cancel the sheet.
        let tapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(didTapBackdrop(_:)))
        tapGestureRecognizer.delegate = self
        view.addGestureRecognizer(tapGestureRecognizer)

        // Setup handle for interactive dismissal / resizing
        setupInteractiveSizing()

        if #available(iOS 26.0, *), isOnGlass {
            sheetContainerView.backgroundColor = .clear
            let glassBackground = UIVisualEffectView(effect: UIGlassEffect(style: .regular))
            sheetContainerView.insertSubview(glassBackground, at: 0)
            glassBackground.autoPinEdges(toEdgesOf: sheetStackView)
            let topRadius: CGFloat = if UIDevice.current.hasIPhoneXNotch {
                40
            } else {
                20
            }
            glassBackground.cornerConfiguration = .uniformEdges(
                topRadius: .fixed(topRadius),
                bottomRadius: .containerConcentric(minimum: 20),
            )
        } else {
            sheetContainerView.backgroundColor = sheetBackgroundColor
        }
    }

    override open func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        dismissalDelegate?.didDismissPresentedSheet()
    }

    override open func themeDidChange() {
        super.themeDidChange()

        handle.backgroundColor = handleBackgroundColor
        sheetContainerView.backgroundColor = if isOnGlass {
            .clear
        } else {
            sheetBackgroundColor
        }
    }

    @objc
    private func didTapBackdrop(_ sender: UITapGestureRecognizer) {
        guard canBeDismissed else {
            return
        }
        willDismissInteractively()
        dismiss(animated: true)
    }

    // MARK: - Resize / Interactive Dismiss

    private func updateMaxHeight() {
        if allowsExpansion {
            maxHeight = maximumPreferredHeight()
        } else {
            maxHeight = minHeight
        }
    }

    public final var allowsExpansion: Bool = true {
        didSet {
            self.updateMaxHeight()
            guard isViewLoaded else {
                return
            }
            if
                !isInInteractiveTransition,
                !isDismissingFromPanGesture,
                sheetCurrentHeightConstraint.constant > minHeight
            {
                sheetCurrentHeightConstraint.constant = minHeight
            }
        }
    }

    private var minHeight: CGFloat = Constants.defaultMinHeight {
        didSet {
            if !allowsExpansion {
                maxHeight = minHeight
            }
            guard isViewLoaded else {
                return
            }
            sheetHeightMinConstraint.constant = minHeight
            if
                !isInInteractiveTransition,
                !isDismissingFromPanGesture,
                sheetCurrentHeightConstraint.constant == oldValue
                || sheetCurrentHeightConstraint.constant < minHeight
            {
                sheetCurrentHeightConstraint.constant = minHeight
            }
        }
    }

    private var externalMinHeight: CGFloat?

    public final var minimizedHeight: CGFloat {
        get {
            return minHeight
        }
        set {
            externalMinHeight = newValue
            self.minHeight = min(newValue, maximumPreferredHeight())
        }
    }

    public private(set) final lazy var maxHeight = maximumPreferredHeight()

    private lazy var sheetHeightMinConstraint = sheetContainerView.autoSetDimension(
        .height,
        toSize: minHeight,
        relation: .greaterThanOrEqual,
    )

    private lazy var sheetHeightMaxConstraint = sheetContainerView.autoSetDimension(
        .height,
        toSize: maxHeight,
        relation: .lessThanOrEqual,
    )

    private lazy var sheetCurrentHeightConstraint = sheetContainerView.autoSetDimension(.height, toSize: minHeight)

    private var sheetCurrentOffsetConstraint: NSLayoutConstraint?

    private var currentVisibleHeight: CGFloat {
        sheetCurrentHeightConstraint.constant - (sheetCurrentOffsetConstraint?.constant ?? 0)
    }

    public func minimizeHeight(animated: Bool = true) {
        self.cancelAnimationAndUpdateConstraints()

        sheetCurrentHeightConstraint.constant = minHeight
        guard animated else {
            view.layoutIfNeeded()
            self.heightDidChange(to: .min)
            return
        }

        view.setNeedsUpdateConstraints()
        self.animate {
            self.view.layoutIfNeeded()
            self.heightDidChange(to: .min)
        }
    }

    public func maximizeHeight(animated: Bool = true, completion: (() -> Void)? = nil) {
        self.cancelAnimationAndUpdateConstraints()

        sheetCurrentHeightConstraint.constant = maxHeight
        guard animated else {
            view.layoutIfNeeded()
            self.heightDidChange(to: .max)
            completion?()
            return
        }

        view.setNeedsUpdateConstraints()
        self.animate(
            animations: {
                self.view.layoutIfNeeded()
                self.heightDidChange(to: .max)
            },
            completion: completion,
        )
    }

    /// When `true`, uses a slower, smoother, interruptible animation curve for
    /// height changes using a UIViewPropertyAnimator. This can have unintended
    /// side effects, however, such as reloading table content in an animation
    /// block resulting is strange behavior, so it is disabled by default.
    public var animationsShouldBeInterruptible = false

    private var animator: UIViewPropertyAnimator?

    public func animate(
        animations: @escaping () -> Void,
        completion: (() -> Void)? = nil,
    ) {
        if animationsShouldBeInterruptible {
            let animator = UIViewPropertyAnimator(
                duration: 0.5,
                controlPoint1: .init(x: 0.25, y: 1),
                controlPoint2: .init(x: 0.25, y: 1),
            )
            animator.addAnimations(animations)
            animator.addCompletion { [weak self] _ in
                self?.animator = nil
                completion?()
            }
            animator.startAnimation()
            self.animator = animator
        } else {
            UIView.animate(
                withDuration: 0.3,
                delay: 0,
                usingSpringWithDamping: 4 * .pi / 0.3,
                initialSpringVelocity: 0,
                animations: animations,
                completion: completion.map { closure in { _ in closure() } },
            )
        }
    }

    // If either of these are set, min/max height changes will not take immediate effect.
    private var isInInteractiveTransition = false
    private var isDismissingFromPanGesture = false

    private var startingHeight: CGFloat?
    private var startingOffset: CGFloat?
    private var startingTranslation: CGFloat?

    private func setupInteractiveSizing() {
        view.addConstraints([sheetCurrentHeightConstraint, sheetHeightMinConstraint, sheetHeightMaxConstraint])

        // Create a pan gesture to handle when the user interacts with the
        // view outside of any scroll views we want to follow.
        let panGestureRecognizer = DirectionalPanGestureRecognizer(direction: .vertical, target: self, action: #selector(handlePan))
        view.addGestureRecognizer(panGestureRecognizer)
        panGestureRecognizer.delegate = self

        // We also want to handle the pan gesture for all of the scroll
        // views, so we can do a nice scroll to dismiss gesture, and
        // so we can transfer any initial scrolling into maximizing
        // the view.
        interactiveScrollViews.forEach { $0.panGestureRecognizer.addTarget(self, action: #selector(handlePan)) }
    }

    /// The maximum height the sheet wants to be. It can be "sprung" past this
    /// point up until `maximumAllowedHeight`, if that is higher than this.
    ///
    /// By default, it returns `maximumAllowedHeight()`.
    open func maximumPreferredHeight() -> CGFloat {
        self.maximumAllowedHeight()
    }

    /// The maximum height the sheet can ever get.
    open func maximumAllowedHeight() -> CGFloat {
        return CurrentAppContext().frame.height - (view.safeAreaInsets.top + Constants.extraTopPadding)
    }

    override open func viewSafeAreaInsetsDidChange() {
        super.viewSafeAreaInsetsDidChange()
        let oldMaxHeight = maxHeight
        let newMaxHeight = maximumPreferredHeight()
        if allowsExpansion {
            maxHeight = newMaxHeight
        }
        if minHeight > maxHeight {
            minHeight = maxHeight
        } else if minHeight == oldMaxHeight, let externalMinHeight {
            minimizedHeight = externalMinHeight
        }

        guard isViewLoaded else {
            return
        }
        sheetHeightMaxConstraint.constant = maxHeight
        if
            !isInInteractiveTransition,
            !isDismissingFromPanGesture,
            (
                sheetCurrentHeightConstraint.constant == oldMaxHeight
                    && sheetCurrentHeightConstraint.constant != minHeight
            )
            || sheetCurrentHeightConstraint.constant > maxHeight
        {
            sheetCurrentHeightConstraint.constant = maxHeight
        }
    }

    @objc
    private func handlePan(_ sender: UIPanGestureRecognizer) {
        let panningScrollView = interactiveScrollViews.first { $0.panGestureRecognizer == sender }

        switch sender.state {
        case .began:
            self.cancelAnimationAndUpdateConstraints()
            sheetPanDelegate?.sheetPanDidBegin()
            fallthrough
        case .changed:
            guard
                beginInteractiveTransitionIfNecessary(sender),
                var startingHeight,
                let startingOffset,
                let startingTranslation
            else {
                return resetInteractiveTransition(panningScrollView: panningScrollView)
            }

            // We're in an interactive transition, so don't let the scrollView scroll.
            if let panningScrollView {
                panningScrollView.contentOffset.y = -panningScrollView.contentInset.top
                panningScrollView.showsVerticalScrollIndicator = false
            }

            // We may have panned some distance if we were scrolling before we started
            // this interactive transition. Offset the translation we use to move the
            // view by whatever the translation was when we started the interactive
            // portion of the gesture.
            let translation = sender.translation(in: view).y - startingTranslation

            startingHeight -= startingOffset

            let resistanceDivisor: CGFloat = 3
            func adjustStartingHeightForBeingOutOfBounds(bound: CGFloat) {
                let distanceOutOfBounds = startingHeight - bound
                startingHeight = bound + distanceOutOfBounds * resistanceDivisor
            }

            if startingHeight > self.maxHeight {
                adjustStartingHeightForBeingOutOfBounds(bound: self.maxHeight)
            } else if !canBeDismissed, startingHeight < self.minHeight {
                adjustStartingHeightForBeingOutOfBounds(bound: self.minHeight)
            }

            var newOffset = 0 as CGFloat
            var newHeight = startingHeight - translation

            // Add resistance above the max preferred height
            if newHeight > maxHeight {
                if isOnGlass {
                    // Doing a transform keeps the glass background the same
                    // height and prevents its concentric corners from shirking
                    // as they get farther from the edges of the screen.
                    sheetContainerView.transform = .translate(.init(x: 0, y: (maxHeight - newHeight) / resistanceDivisor))
                    newHeight = maxHeight
                } else {
                    // When not on glass, we want the bottom of the sheet to
                    // extend to the bottom of the screen, so don't transform.
                    newHeight = maxHeight + (newHeight - maxHeight) / resistanceDivisor
                }
            }

            // Don't go past the max allowed height
            let maxAllowedHeight = self.maximumAllowedHeight()
            if newHeight > maxAllowedHeight {
                newHeight = maxAllowedHeight
            }

            // Don't shrink below minHeight and instead offset down
            if newHeight < minHeight {
                newOffset = minHeight - newHeight
                newHeight = minHeight
            }

            // Add resistance below the min height
            if !canBeDismissed {
                newOffset /= resistanceDivisor
            }

            let newVisibleHeight = newHeight - newOffset

            if newVisibleHeight != startingHeight {
                heightDidChange(to: .height(newHeight))
            }

            // If the height is decreasing, adjust the relevant view's proportionally
            if newHeight < startingHeight {
                backdropView?.alpha = 1 - (startingHeight - newVisibleHeight) / startingHeight
            }

            // Update our offset/height to reflect the new position
            sheetCurrentOffsetConstraint?.constant = newOffset
            sheetCurrentHeightConstraint.constant = newHeight
            view.layoutIfNeeded()
        case .ended, .cancelled, .failed:
            sheetPanDelegate?.sheetPanDidEnd()
            let currentVisibleHeight = self.currentVisibleHeight
            let currentVelocity = sender.velocity(in: view).y

            enum CompletionState { case growing, shrinking, dismissing }
            let completionState: CompletionState

            if currentVelocity <= -Constants.maximizeVelocityThreshold {
                completionState = .growing
            } else if
                canBeDismissed,
                currentVelocity >= Constants.dismissVelocityThreshold,
                dismissesWithHighVelocitySwipe || isInInteractiveTransition
            {
                completionState = .dismissing
            } else if currentVisibleHeight >= minHeight {
                if
                    currentVelocity > Constants.baseVelocityThreshold,
                    shrinksWithHighVelocitySwipe,
                    panningScrollView.map({ $0.contentOffset.y <= -$0.contentInset.top }) ?? true
                {
                    completionState = .shrinking
                } else if currentVelocity < -Constants.baseVelocityThreshold {
                    completionState = .growing
                } else {
                    completionState =
                        currentVisibleHeight < (maxHeight + minHeight) / 2
                            ? .shrinking : .growing
                }
            } else {
                if abs(currentVelocity) > Constants.baseVelocityThreshold {
                    completionState = currentVelocity > 0 && canBeDismissed ? .dismissing : .shrinking
                } else {
                    completionState =
                        currentVisibleHeight < minHeight / 2 && canBeDismissed
                            ? .dismissing : .shrinking
                }
            }

            self.updateMaxHeight()

            let finalOffset: CGFloat
            let finalHeight: CGFloat
            switch completionState {
            case .dismissing:
                isDismissingFromPanGesture = true
                finalOffset = minHeight
                finalHeight = minHeight
            case .growing:
                finalOffset = 0
                finalHeight = maxHeight
            case .shrinking:
                finalOffset = 0
                finalHeight = minHeight
            }

            sheetPanDelegate?.sheetPanDecelerationDidBegin()
            self.animate {
                self.sheetContainerView.transform = .identity
                self.sheetCurrentOffsetConstraint?.constant = finalOffset
                self.sheetCurrentHeightConstraint.constant = finalHeight
                self.view.layoutIfNeeded()

                switch completionState {
                case .growing:
                    self.heightDidChange(to: .max)
                case .shrinking, .dismissing:
                    self.heightDidChange(to: .min)
                }

                self.backdropView?.alpha = completionState == .dismissing ? 0 : 1
            } completion: {
                self.sheetPanDelegate?.sheetPanDecelerationDidEnd()
                self.heightDidChange(to: .height(finalHeight))
                if completionState == .dismissing, self.canBeDismissed {
                    self.willDismissInteractively()
                    self.dismiss(animated: true, completion: { [weak self] in
                        self?.isDismissingFromPanGesture = false
                    })
                }
            }

            resetInteractiveTransition(panningScrollView: panningScrollView)
        default:
            resetInteractiveTransition(panningScrollView: panningScrollView)

            backdropView?.alpha = 1

            guard let startingHeight else { break }
            sheetCurrentOffsetConstraint?.constant = 0
            sheetCurrentHeightConstraint.constant = startingHeight
            heightDidChange(to: .height(startingHeight))
        }
    }

    public func cancelAnimationAndUpdateConstraints() {
        guard let animator else { return }
        animator.stopAnimation(false)
        animator.finishAnimation(at: .current)
        self.updateConstraintsAfterCanceledAnimation()
    }

    private func updateConstraintsAfterCanceledAnimation() {
        let sheetBottom = self.view.convert(sheetContainerView.frame, from: self.view).maxY
        let offset = sheetBottom - self.view.frame.maxY
        sheetCurrentOffsetConstraint?.constant = offset

        sheetCurrentHeightConstraint.constant = sheetContainerView.height

        self.view.layoutIfNeeded()
    }

    public final func refreshMaxHeight() {
        guard !isInInteractiveTransition else { return }

        let oldMaxHeight = self.maxHeight
        self.maxHeight = maximumPreferredHeight()
        self.sheetHeightMaxConstraint.constant = self.maxHeight
        if self.sheetCurrentHeightConstraint.constant == oldMaxHeight {
            self.cancelAnimationAndUpdateConstraints()
            self.sheetCurrentOffsetConstraint?.constant = 0
            self.sheetCurrentHeightConstraint.constant = self.maxHeight
            self.animate {
                self.view.setNeedsLayout()
                self.view.layoutIfNeeded()
                self.heightDidChange(to: .max)
            }
        }
    }

    public enum SheetHeight {
        case min
        case height(CGFloat)
        case max
    }

    open func heightDidChange(to height: SheetHeight) {}

    private func beginInteractiveTransitionIfNecessary(_ sender: UIPanGestureRecognizer) -> Bool {
        let panningScrollView = interactiveScrollViews.first { $0.panGestureRecognizer == sender }

        // If we're at the top of the scrollView, the view is not
        // currently maximized, or we're panning outside of the scroll
        // view we want to do an interactive transition.

        var isScrollingPastTop: Bool {
            guard let panningScrollView else { return false }
            return panningScrollView.contentOffset.y <= 0
        }

        var isScrollingPastBottom: Bool {
            guard let panningScrollView else { return false }
            let hasScrollableContent = panningScrollView.contentSize.height <= panningScrollView.height
            let contentIsPastBottom = panningScrollView.contentOffset.y + panningScrollView.height > panningScrollView.contentSize.height
            return hasScrollableContent && contentIsPastBottom
        }

        guard
            isScrollingPastTop
            || isScrollingPastBottom
            || currentVisibleHeight < maxHeight
            || panningScrollView == nil
        else {
            return false
        }

        if !isInInteractiveTransition {
            self.updateMaxHeight()
        }

        if startingTranslation == nil {
            startingTranslation = sender.translation(in: view).y
        }

        if startingHeight == nil {
            startingHeight = sheetContainerView.height
        }
        if startingOffset == nil {
            startingOffset = sheetCurrentOffsetConstraint?.constant ?? 0
        }
        isInInteractiveTransition = true
        return true
    }

    private func resetInteractiveTransition(panningScrollView: UIScrollView?) {
        startingTranslation = nil
        startingHeight = nil
        startingOffset = nil
        isInInteractiveTransition = false
        panningScrollView?.showsVerticalScrollIndicator = true
    }

    override public func accessibilityPerformEscape() -> Bool {
        if presentingViewController != nil {
            dismiss(animated: true)
            return true
        }
        return super.accessibilityPerformEscape()
    }
}

// MARK: -

extension InteractiveSheetViewController: UIGestureRecognizerDelegate {
    public func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
        switch gestureRecognizer {
        case is UITapGestureRecognizer:
            let point = gestureRecognizer.location(in: view)
            return !sheetContainerView.frame.contains(point)
        default:
            return true
        }
    }

    public func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRequireFailureOf otherGestureRecognizer: UIGestureRecognizer) -> Bool {
        switch gestureRecognizer {
        case is UIPanGestureRecognizer:
            return interactiveScrollViews.map { $0.panGestureRecognizer }.contains(otherGestureRecognizer)
        default:
            return false
        }
    }
}

// MARK: -

private class InteractiveSheetAnimationController: UIPresentationController {

    var backdropView: UIView? {
        guard let vc = presentedViewController as? InteractiveSheetViewController else { return nil }
        return vc.backdropView
    }

    var isUsingExternalBackdropView: Bool {
        guard let vc = presentedViewController as? InteractiveSheetViewController else { return false }
        return vc.externalBackdropView != nil
    }

    init(presentedViewController: UIViewController, presenting presentingViewController: UIViewController?, backdropColor: UIColor? = .Signal.backdrop) {
        super.init(presentedViewController: presentedViewController, presenting: presentingViewController)
        backdropView?.backgroundColor = backdropColor
    }

    override func presentationTransitionWillBegin() {
        if !isUsingExternalBackdropView, let containerView, let backdropView {
            backdropView.alpha = 0
            containerView.addSubview(backdropView)
            backdropView.autoPinEdgesToSuperviewEdges()
            containerView.layoutIfNeeded()
        }

        presentedViewController.transitionCoordinator?.animate(alongsideTransition: { _ in
            self.backdropView?.alpha = 1
        }, completion: nil)
    }

    override func dismissalTransitionWillBegin() {
        presentedViewController.transitionCoordinator?.animate(alongsideTransition: { _ in
            self.backdropView?.alpha = 0
        }, completion: { _ in
            self.backdropView?.removeFromSuperview()
        })
    }

    override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
        super.viewWillTransition(to: size, with: coordinator)
        guard let presentedView else { return }
        coordinator.animate(alongsideTransition: { _ in
            presentedView.frame = self.frameOfPresentedViewInContainerView
            presentedView.layoutIfNeeded()
        }, completion: nil)
    }
}

extension InteractiveSheetViewController: UIViewControllerTransitioningDelegate {
    open func presentationController(forPresented presented: UIViewController, presenting: UIViewController?, source: UIViewController) -> UIPresentationController? {
        let controller = InteractiveSheetAnimationController(presentedViewController: presented, presenting: presenting, backdropColor: self.backdropColor)
        return controller
    }
}

public protocol SheetPanDelegate: AnyObject {
    func sheetPanDidBegin()
    func sheetPanDidEnd()
    func sheetPanDecelerationDidBegin()
    func sheetPanDecelerationDidEnd()
}
