//
//  GalleryItemViewController.swift
//  GalleryVC
//
//  Created by Shadowfacts on 12/28/23.
//

import UIKit
import AVFoundation

@MainActor
protocol GalleryItemViewControllerDelegate: AnyObject {
    func isGalleryBeingPresented() -> Bool
    func addPresentationAnimationCompletion(_ block: @escaping () -> Void)
    func galleryItemClose(_ item: GalleryItemViewController)
    func galleryItemApplicationActivities(_ item: GalleryItemViewController) -> [UIActivity]?
}

class GalleryItemViewController: UIViewController {
    private weak var delegate: GalleryItemViewControllerDelegate?
    
    let itemIndex: Int
    let content: GalleryContentViewController
    private var overlayVC: UIViewController?
    
    private var activityIndicator: UIActivityIndicatorView?
    private(set) var scrollView: UIScrollView!
    private var topControlsView: UIView!
    private var shareButton: UIButton!
    private var shareButtonLeadingConstraint: NSLayoutConstraint!
    private var shareButtonTopConstraint: NSLayoutConstraint!
    private var closeButtonTrailingConstraint: NSLayoutConstraint!
    private var closeButtonTopConstraint: NSLayoutConstraint!
    private var bottomControlsView: UIStackView!
    private(set) var captionTextView: UITextView!
    
    private var singleTap: UITapGestureRecognizer!
    private var doubleTap: UITapGestureRecognizer!

    private var contentViewLeadingConstraint: NSLayoutConstraint?
    private var contentViewTopConstraint: NSLayoutConstraint?

    private(set) var controlsVisible: Bool = true
    private(set) var scrollAndZoomEnabled = true
    
    override var prefersHomeIndicatorAutoHidden: Bool {
        return !controlsVisible
    }
    
    init(delegate: GalleryItemViewControllerDelegate, itemIndex: Int, content: GalleryContentViewController) {
        self.delegate = delegate
        self.itemIndex = itemIndex
        self.content = content
        
        super.init(nibName: nil, bundle: nil)
        
        content.container = self
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let scrollView = UIScrollView()
        self.scrollView = scrollView
        scrollView.translatesAutoresizingMaskIntoConstraints = false
        scrollView.delegate = self
        
        view.addSubview(scrollView)
        
        addContent()
        centerContent()
        
        overlayVC = content.contentOverlayAccessoryViewController
        if let overlayVC {
            overlayVC.view.isHidden = activityIndicator != nil
            overlayVC.view.translatesAutoresizingMaskIntoConstraints = false
            view.addSubview(overlayVC.view)
            NSLayoutConstraint.activate([
                overlayVC.view.leadingAnchor.constraint(equalTo: content.view.leadingAnchor),
                overlayVC.view.trailingAnchor.constraint(equalTo: content.view.trailingAnchor),
                overlayVC.view.topAnchor.constraint(equalTo: content.view.topAnchor),
                overlayVC.view.bottomAnchor.constraint(equalTo: content.view.bottomAnchor),
            ])
        }
        
        topControlsView = UIView()
        topControlsView.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(topControlsView)
        
        var shareConfig = UIButton.Configuration.plain()
        shareConfig.baseForegroundColor = .white
        shareConfig.image = UIImage(systemName: "square.and.arrow.up")
        shareButton = UIButton(configuration: shareConfig)
        shareButton.addTarget(self, action: #selector(shareButtonPressed), for: .touchUpInside)
        shareButton.translatesAutoresizingMaskIntoConstraints = false
        updateShareButton()
        topControlsView.addSubview(shareButton)
        
        var closeConfig = UIButton.Configuration.plain()
        closeConfig.baseForegroundColor = .white
        closeConfig.image = UIImage(systemName: "xmark")
        let closeButton = UIButton(configuration: closeConfig)
        closeButton.addTarget(self, action: #selector(closeButtonPressed), for: .touchUpInside)
        closeButton.translatesAutoresizingMaskIntoConstraints = false
        topControlsView.addSubview(closeButton)
        
        bottomControlsView = UIStackView()
        bottomControlsView.translatesAutoresizingMaskIntoConstraints = false
        bottomControlsView.axis = .vertical
        bottomControlsView.alignment = .fill
        bottomControlsView.backgroundColor = .black.withAlphaComponent(0.5)
        view.addSubview(bottomControlsView)
        
        if let controlsAccessory = content.bottomControlsAccessoryViewController {
            addChild(controlsAccessory)
            bottomControlsView.addArrangedSubview(controlsAccessory.view)
            controlsAccessory.didMove(toParent: self)
            
            // Make sure the controls accessory is within the safe area.
            let spacer = UIView()
            bottomControlsView.addArrangedSubview(spacer)
            let spacerTopConstraint = spacer.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor)
            spacerTopConstraint.priority = .init(999)
            spacerTopConstraint.isActive = true
        }
        
        captionTextView = UITextView()
        captionTextView.backgroundColor = .clear
        captionTextView.textColor = .white
        captionTextView.isEditable = false
        captionTextView.isSelectable = true
        captionTextView.font = .preferredFont(forTextStyle: .body)
        captionTextView.adjustsFontForContentSizeCategory = true
        captionTextView.alwaysBounceVertical = true
        updateCaptionTextView()
        bottomControlsView.addArrangedSubview(captionTextView)
        
        closeButtonTrailingConstraint = topControlsView.trailingAnchor.constraint(equalTo: closeButton.trailingAnchor)
        closeButtonTopConstraint = closeButton.topAnchor.constraint(equalTo: topControlsView.topAnchor)
        shareButtonLeadingConstraint = shareButton.leadingAnchor.constraint(equalTo: topControlsView.leadingAnchor)
        shareButtonTopConstraint = shareButton.topAnchor.constraint(equalTo: topControlsView.topAnchor)

        NSLayoutConstraint.activate([
            scrollView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            scrollView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            scrollView.topAnchor.constraint(equalTo: view.topAnchor),
            scrollView.bottomAnchor.constraint(equalTo: view.bottomAnchor),
            
            topControlsView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            topControlsView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            topControlsView.topAnchor.constraint(equalTo: view.topAnchor),

            shareButtonLeadingConstraint,
            shareButtonTopConstraint,
            shareButton.bottomAnchor.constraint(equalTo: topControlsView.bottomAnchor),
            
            closeButtonTrailingConstraint,
            closeButtonTopConstraint,
            closeButton.bottomAnchor.constraint(equalTo: topControlsView.bottomAnchor),

            bottomControlsView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            bottomControlsView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            bottomControlsView.bottomAnchor.constraint(equalTo: view.bottomAnchor),
            
            captionTextView.heightAnchor.constraint(equalToConstant: 150),
        ])
        
        singleTap = UITapGestureRecognizer(target: self, action: #selector(viewPressed))
        singleTap.delegate = self
        doubleTap = UITapGestureRecognizer(target: self, action: #selector(viewDoublePressed))
        doubleTap.delegate = self
        doubleTap.numberOfTapsRequired = 2
        // this requirement is needed to make sure the double tap is ever recognized
        singleTap.require(toFail: doubleTap)
        view.addGestureRecognizer(singleTap)
        view.addGestureRecognizer(doubleTap)
    }
    
    override func viewSafeAreaInsetsDidChange() {
        super.viewSafeAreaInsetsDidChange()
        
        updateZoomScale(resetZoom: false)
        // Ensure the transform is correct if the controls are hidden
        setControlsVisible(controlsVisible, animated: false)
        
        updateTopControlsInsets()
    }
    
    override func viewDidLayoutSubviews() {
        super.viewDidLayoutSubviews()
        
        centerContent()
    }
    
    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        
        if controlsVisible && !captionTextView.isHidden {
            captionTextView.flashScrollIndicators()
        }
    }
    
    func takeContent() -> GalleryContentViewController {
        content.willMove(toParent: nil)
        content.removeFromParent()
        content.view.removeFromSuperview()
        return content
    }
    
    func addContent() {
        content.loadViewIfNeeded()
        
        content.setControlsVisible(controlsVisible, animated: false)
        
        content.view.translatesAutoresizingMaskIntoConstraints = false
        if content.parent != self {
            addChild(content)
            content.didMove(toParent: self)
        }
        if scrollAndZoomEnabled {
            scrollView.addSubview(content.view)
            contentViewLeadingConstraint = content.view.leadingAnchor.constraint(equalTo: scrollView.leadingAnchor)
            contentViewLeadingConstraint!.isActive = true
            contentViewTopConstraint = content.view.topAnchor.constraint(equalTo: scrollView.topAnchor)
            contentViewTopConstraint!.isActive = true
            updateZoomScale(resetZoom: true)
        } else {
            // If the content was previously added, deactivate the old constraints.
            contentViewLeadingConstraint?.isActive = false
            contentViewTopConstraint?.isActive = false
            
            view.addSubview(content.view)
            NSLayoutConstraint.activate([
                content.view.leadingAnchor.constraint(equalTo: view.leadingAnchor),
                content.view.trailingAnchor.constraint(equalTo: view.trailingAnchor),
                content.view.topAnchor.constraint(equalTo: view.topAnchor),
                content.view.bottomAnchor.constraint(equalTo: view.bottomAnchor),
            ])
        }
        
        if let overlayVC {
            NSLayoutConstraint.activate([
                overlayVC.view.leadingAnchor.constraint(equalTo: view.leadingAnchor),
                overlayVC.view.trailingAnchor.constraint(equalTo: view.trailingAnchor),
                overlayVC.view.topAnchor.constraint(equalTo: view.topAnchor),
                overlayVC.view.bottomAnchor.constraint(equalTo: view.bottomAnchor),
            ])
        }
        
        content.view.layoutIfNeeded()
    }
    
    func setControlsVisible(_ visible: Bool, animated: Bool) {
        controlsVisible = visible
        guard let topControlsView,
              let bottomControlsView else {
            return
        }
        func updateControlsViews() {
            topControlsView.transform = CGAffineTransform(translationX: 0, y: visible ? 0 : -topControlsView.bounds.height)
            bottomControlsView.transform = CGAffineTransform(translationX: 0, y: visible ? 0 : bottomControlsView.bounds.height)
            content.setControlsVisible(visible, animated: animated)
        }
        if animated {
            let animator = UIViewPropertyAnimator(duration: 0.2, timingParameters: UISpringTimingParameters())
            animator.addAnimations(updateControlsViews)
            animator.startAnimation()
        } else {
            updateControlsViews()
        }
        
        setNeedsUpdateOfHomeIndicatorAutoHidden()
    }
    
    private func updateZoomScale(resetZoom: Bool) {
        guard scrollAndZoomEnabled else {
            scrollView.maximumZoomScale = 1
            scrollView.minimumZoomScale = 1
            scrollView.zoomScale = 1
            return
        }
        
        guard content.contentSize.width > 0 && content.contentSize.height > 0 else {
            return
        }
        
        let heightScale = view.safeAreaLayoutGuide.layoutFrame.height / content.contentSize.height
        let widthScale = view.safeAreaLayoutGuide.layoutFrame.width / content.contentSize.width
        let minScale = min(widthScale, heightScale)
        let maxScale = minScale >= 1 ? minScale + 2 : 2
        
        scrollView.minimumZoomScale = minScale
        scrollView.maximumZoomScale = maxScale
        if resetZoom {
            scrollView.zoomScale = minScale
        } else {
            scrollView.zoomScale = max(minScale, min(maxScale, scrollView.zoomScale))
        }
        
        centerContent()
    }
    
    private func centerContent() {
        guard scrollAndZoomEnabled else {
            return
        }
        
        // Note: use frame for the content.view, because that's in the coordinate space of the scroll view
        // which means it's already been scaled by the zoom factor.
        let yOffset = max(0, (view.bounds.height - content.view.frame.height) / 2)
        contentViewTopConstraint!.constant = yOffset
        
        let xOffset = max(0, (view.bounds.width - content.view.frame.width) / 2)
        contentViewLeadingConstraint!.constant = xOffset
    }
    
    private func updateShareButton() {
        shareButton.isEnabled = !content.activityItemsForSharing.isEmpty
    }
    
    private func updateCaptionTextView() {
        guard let caption = content.caption,
              !caption.isEmpty else {
            captionTextView.isHidden = true
            return
        }
        captionTextView.text = caption
    }
    
    private func updateTopControlsInsets() {
        let notchedDeviceTopInsets: [CGFloat] = [
            44, // iPhone X, Xs, Xs Max, 11 Pro, 11 Pro Max
            48, // iPhone XR, 11
            47, // iPhone 12, 12 Pro, 12 Pro Max, 13, 13 Pro, 13 Pro Max, 14, 14 Plus
            50, // iPhone 12 mini, 13 mini
        ]
        let islandDeviceTopInsets: [CGFloat] = [
            59, // iPhone 14 Pro, 14 Pro Max, 15 Pro, 15 Pro Max
        ]
        if notchedDeviceTopInsets.contains(view.safeAreaInsets.top) {
            // the notch width is not the same for the iPhones 13,
            // but what we actually want is the same offset from the edges
            // since the corner radius didn't change
            let notchWidth: CGFloat = 210
            let earWidth = (view.bounds.width - notchWidth) / 2
            let offset = (earWidth - (shareButton.imageView?.bounds.width ?? 0)) / 2
            shareButtonLeadingConstraint.constant = offset
            closeButtonTrailingConstraint.constant = offset
        } else if islandDeviceTopInsets.contains(view.safeAreaInsets.top) {
            shareButtonLeadingConstraint.constant = 24
            shareButtonTopConstraint.constant = 24
            closeButtonTrailingConstraint.constant = 24
            closeButtonTopConstraint.constant = 24
        }
    }
    
    private func zoomRectFor(scale: CGFloat, center: CGPoint) -> CGRect {
        var zoomRect = CGRect.zero
        zoomRect.size.width = content.view.frame.width / scale
        zoomRect.size.height = content.view.frame.height / scale
        let newCenter = scrollView.convert(center, to: content.view)
        zoomRect.origin.x = newCenter.x - (zoomRect.width / 2)
        zoomRect.origin.y = newCenter.y - (zoomRect.height / 2)
        return zoomRect
    }
    
    private func animateZoomOut() {
        let animator = UIViewPropertyAnimator(duration: 0.3, timingParameters: UISpringTimingParameters())
        animator.addAnimations {
            self.scrollView.zoomScale = self.scrollView.minimumZoomScale
            self.scrollView.layoutIfNeeded()
        }
        animator.startAnimation()
    }

    // MARK: Interaction
    
    @objc private func viewPressed() {
        if scrollAndZoomEnabled,
           scrollView.zoomScale > scrollView.minimumZoomScale {
            animateZoomOut()
        } else {
            setControlsVisible(!controlsVisible, animated: true)
        }
    }
    
    @objc private func viewDoublePressed(_ recognizer: UITapGestureRecognizer) {
        guard scrollAndZoomEnabled else {
            return
        }
        if scrollView.zoomScale <= scrollView.minimumZoomScale {
            let point = recognizer.location(in: recognizer.view)
            let scale = min(
                max(
                    scrollView.bounds.width / content.contentSize.width,
                    scrollView.bounds.height / content.contentSize.height,
                    scrollView.zoomScale + 0.75
                ),
                scrollView.maximumZoomScale
            )
            let rect = zoomRectFor(scale: scale, center: point)
            let animator = UIViewPropertyAnimator(duration: 0.3, timingParameters: UISpringTimingParameters())
            animator.addAnimations {
                self.scrollView.zoom(to: rect, animated: false)
                self.view.layoutIfNeeded()
            }
            animator.startAnimation()
        } else {
            animateZoomOut()
        }
    }
    
    @objc private func closeButtonPressed() {
        delegate?.galleryItemClose(self)
    }
    
    @objc private func shareButtonPressed() {
        let items = content.activityItemsForSharing
        guard !items.isEmpty else {
            return
        }
        let activityVC = UIActivityViewController(activityItems: items, applicationActivities: delegate?.galleryItemApplicationActivities(self))
        activityVC.popoverPresentationController?.sourceView = shareButton
        present(activityVC, animated: true)
    }
    
}

extension GalleryItemViewController: GalleryContentViewControllerContainer {
    var galleryControlsVisible: Bool {
        controlsVisible
    }
    
    func setGalleryContentLoading(_ loading: Bool) {
        if loading {
            overlayVC?.view.isHidden = true
            if activityIndicator == nil {
                let activityIndicator = UIActivityIndicatorView(style: .large)
                self.activityIndicator = activityIndicator
                activityIndicator.startAnimating()
                activityIndicator.translatesAutoresizingMaskIntoConstraints = false
                view.addSubview(activityIndicator)
                NSLayoutConstraint.activate([
                    activityIndicator.centerXAnchor.constraint(equalTo: view.centerXAnchor),
                    activityIndicator.centerYAnchor.constraint(equalTo: view.centerYAnchor),
                ])
            }
        } else {
            if let activityIndicator {
                // If we're in the middle of the presentation animation,
                // wait until it finishes to hide the loading indicator.
                // Since the updated content frame won't affect the animation,
                // make sure the loading indicator remains visible.
                if let delegate,
                   delegate.isGalleryBeingPresented() {
                    delegate.addPresentationAnimationCompletion { [unowned self] in
                        self.setGalleryContentLoading(false)
                    }
                } else {
                    activityIndicator.removeFromSuperview()
                    self.activityIndicator = nil
                    self.overlayVC?.view.isHidden = false
                }
            }
        }
    }
    
    func galleryContentChanged() {
        updateZoomScale(resetZoom: true)
        updateShareButton()
        updateCaptionTextView()
    }
    
    func disableGalleryScrollAndZoom() {
        scrollAndZoomEnabled = false
        updateZoomScale(resetZoom: true)
        scrollView.isScrollEnabled = false
        // Make sure the content is re-added with the correct constraints
        if content.parent == self {
            addContent()
        }
    }
    
    func setGalleryControlsVisible(_ visible: Bool, animated: Bool) {
        setControlsVisible(visible, animated: animated)
    }
}

extension GalleryItemViewController: UIScrollViewDelegate {
    func viewForZooming(in scrollView: UIScrollView) -> UIView? {
        if scrollAndZoomEnabled {
            return content.view
        } else {
            return nil
        }
    }
    
    func scrollViewDidZoom(_ scrollView: UIScrollView) {
        if scrollView.zoomScale <= scrollView.minimumZoomScale {
            setControlsVisible(true, animated: true)
        } else {
            setControlsVisible(false, animated: true)
        }
        
        centerContent()
        scrollView.layoutIfNeeded()
    }
}

extension GalleryItemViewController: UIGestureRecognizerDelegate {
    func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
        if gestureRecognizer == singleTap {
            let loc = gestureRecognizer.location(in: view)
            return !topControlsView.frame.contains(loc) && !bottomControlsView.frame.contains(loc)
        } else if gestureRecognizer == doubleTap {
            let loc = gestureRecognizer.location(in: content.view)
            return content.view.bounds.contains(loc)
        } else {
            return true
        }
    }
}