//
//  MediaView.swift
//  MediaView
//
//  Created by Cirno MainasuK on 2021-8-23.
//  Copyright © 2021 Twidere. All rights reserved.
//

import AVKit
import UIKit
import Combine
import AlamofireImage

public final class MediaView: UIView {
    
    var _disposeBag = Set<AnyCancellable>()
    
    public static let cornerRadius: CGFloat = 0
    public static let durationFormatter: DateComponentsFormatter = {
        let formatter = DateComponentsFormatter()
        formatter.zeroFormattingBehavior = .pad
        formatter.allowedUnits = [.minute, .second]
        return formatter
    }()
    
    public let container = TouchBlockingView()
    
    public private(set) var configuration: Configuration?
    
    private(set) lazy var blurhashImageView: UIImageView = {
        let imageView = UIImageView()
        imageView.contentMode = .scaleAspectFill
        imageView.isUserInteractionEnabled = false
        imageView.layer.masksToBounds = true    // clip overflow
        return imageView
    }()
    
    private(set) lazy var imageView: UIImageView = {
        let imageView = UIImageView()
        imageView.contentMode = .scaleAspectFill
        imageView.isUserInteractionEnabled = false
        imageView.layer.masksToBounds = true    // clip overflow
        return imageView
    }()
    
    private(set) lazy var playerViewController: AVPlayerViewController = {
        let playerViewController = AVPlayerViewController()
        playerViewController.view.layer.masksToBounds = true
        playerViewController.view.isUserInteractionEnabled = false
        playerViewController.videoGravity = .resizeAspectFill
        playerViewController.updatesNowPlayingInfoCenter = false
        return playerViewController
    }()
    private var playerLooper: AVPlayerLooper?
    private(set) lazy var playbackImageView: UIImageView = {
        let imageView = UIImageView()
        imageView.image = UIImage(systemName: "play.circle.fill")
        imageView.tintColor = .white
        return imageView
    }()
    
    private(set) lazy var indicatorBlurEffectView: UIVisualEffectView = {
        let effectView = UIVisualEffectView(effect: UIBlurEffect(style: .systemUltraThinMaterial))
        effectView.layer.masksToBounds = true
        effectView.layer.cornerCurve = .continuous
        effectView.layer.cornerRadius = 4
        return effectView
    }()
    private(set) lazy var indicatorVibrancyEffectView = UIVisualEffectView(
        effect: UIVibrancyEffect(blurEffect: UIBlurEffect(style: .systemUltraThinMaterial))
    )
    private(set) lazy var playerIndicatorLabel: UILabel = {
        let label = UILabel()
        label.font = .preferredFont(forTextStyle: .caption1)
        label.textColor = .secondaryLabel
        return label
    }()
    
    public override init(frame: CGRect) {
        super.init(frame: frame)
        _init()
    }
    
    public required init?(coder: NSCoder) {
        super.init(coder: coder)
        _init()
    }
    
}

extension MediaView {
    
    @MainActor
    public func thumbnail() async -> UIImage? {
        return imageView.image ?? configuration?.previewImage
    }
    
    public func thumbnail() -> UIImage? {
        return imageView.image ?? configuration?.previewImage
    }
    
}

extension MediaView {
    private func _init() {
        // lazy load content later
        
        isAccessibilityElement = true
    }
    
    public func setup(configuration: Configuration) {
        self.configuration = configuration

        setupContainerViewHierarchy()
        
        switch configuration.info {
        case .image(let info):
            layoutImage()
            bindImage(configuration: configuration, info: info)
            accessibilityLabel = "Show image"       // TODO: i18n
        case .gif(let info):
            layoutGIF()
            bindGIF(configuration: configuration, info: info)
            accessibilityLabel = "Show GIF"         // TODO: i18n
        case .video(let info):
            layoutVideo()
            bindVideo(configuration: configuration, info: info)
            accessibilityLabel = "Show video player" // TODO: i18n
        }
        
        accessibilityHint = "Tap then hold to show menu"    // TODO: i18n

        layoutBlurhash()
        bindBlurhash(configuration: configuration)
    }
    
    private func layoutImage() {
        imageView.translatesAutoresizingMaskIntoConstraints = false
        container.addSubview(imageView)
        NSLayoutConstraint.activate([
            imageView.topAnchor.constraint(equalTo: container.topAnchor),
            imageView.leadingAnchor.constraint(equalTo: container.leadingAnchor),
            imageView.trailingAnchor.constraint(equalTo: container.trailingAnchor),
            imageView.bottomAnchor.constraint(equalTo: container.bottomAnchor),
        ])
    }
    
    private func bindImage(configuration: Configuration, info: Configuration.ImageInfo) {        
        Publishers.CombineLatest3(
            configuration.$isReveal,
            configuration.$previewImage,
            configuration.$blurhashImage
        )
        .receive(on: DispatchQueue.main)
        .sink { [weak self] isReveal, previewImage, blurhashImage in
            guard let self = self else { return }
            let image = isReveal ? previewImage : blurhashImage
            self.imageView.image = image
        }
        .store(in: &configuration.disposeBag)
    }
        
    private func layoutGIF() {
        // use view controller as View here
        playerViewController.view.translatesAutoresizingMaskIntoConstraints = false
        container.addSubview(playerViewController.view)
        NSLayoutConstraint.activate([
            playerViewController.view.topAnchor.constraint(equalTo: container.topAnchor),
            playerViewController.view.leadingAnchor.constraint(equalTo: container.leadingAnchor),
            playerViewController.view.trailingAnchor.constraint(equalTo: container.trailingAnchor),
            playerViewController.view.bottomAnchor.constraint(equalTo: container.bottomAnchor),
        ])
        
        setupIndicatorViewHierarchy()
        playerIndicatorLabel.attributedText = NSAttributedString(string: "GIF")
    }
    
    private func bindGIF(configuration: Configuration, info: Configuration.VideoInfo) {
        guard let player = setupGIFPlayer(info: info) else { return }
        setupPlayerLooper(player: player)
        playerViewController.player = player
        playerViewController.showsPlaybackControls = false
        
        // auto play for GIF
        player.play()
    }
    
    private func layoutVideo() {
        layoutImage()
        
        playbackImageView.translatesAutoresizingMaskIntoConstraints = false
        container.addSubview(playbackImageView)
        NSLayoutConstraint.activate([
            playbackImageView.centerXAnchor.constraint(equalTo: container.centerXAnchor),
            playbackImageView.centerYAnchor.constraint(equalTo: container.centerYAnchor),
            playbackImageView.widthAnchor.constraint(equalToConstant: 88).priority(.required - 1),
            playbackImageView.heightAnchor.constraint(equalToConstant: 88).priority(.required - 1),
        ])
    }
    
    private func bindVideo(configuration: Configuration, info: Configuration.VideoInfo) {
        let imageInfo = Configuration.ImageInfo(
            aspectRadio: info.aspectRadio,
            assetURL: info.previewURL
        )
        bindImage(configuration: configuration, info: imageInfo)
        
//        indicatorBlurEffectView.translatesAutoresizingMaskIntoConstraints = false
//        imageView.addSubview(indicatorBlurEffectView)
//        NSLayoutConstraint.activate([
//            imageView.trailingAnchor.constraint(equalTo: indicatorBlurEffectView.trailingAnchor, constant: 11),
//            imageView.bottomAnchor.constraint(equalTo: indicatorBlurEffectView.bottomAnchor, constant: 8),
//        ])
//        setupIndicatorViewHierarchy()
        
//        playerIndicatorLabel.attributedText = {
//            let imageAttachment = NSTextAttachment(image: UIImage(systemName: "play.fill")!)
//            let imageAttributedString = AttributedString(NSAttributedString(attachment: imageAttachment))
//            let duration: String = {
//                guard let durationMS = info.durationMS else { return "" }
//                let timeInterval = TimeInterval(durationMS / 1000)
//                guard timeInterval > 0 else { return "" }
//                guard let text = MediaView.durationFormatter.string(from: timeInterval) else { return "" }
//                return " \(text)"
//            }()
//            let textAttributedString = AttributedString("\(duration)")
//            var attributedString = imageAttributedString + textAttributedString
//            attributedString.foregroundColor = .secondaryLabel
//            return NSAttributedString(attributedString)
//        }()
    }
    
    private func layoutBlurhash() {
        blurhashImageView.translatesAutoresizingMaskIntoConstraints = false
        container.addSubview(blurhashImageView)
        NSLayoutConstraint.activate([
            blurhashImageView.topAnchor.constraint(equalTo: container.topAnchor),
            blurhashImageView.leadingAnchor.constraint(equalTo: container.leadingAnchor),
            blurhashImageView.trailingAnchor.constraint(equalTo: container.trailingAnchor),
            blurhashImageView.bottomAnchor.constraint(equalTo: container.bottomAnchor),
        ])
    }
    
    private func bindBlurhash(configuration: Configuration) {
        configuration.$blurhashImage
            .receive(on: DispatchQueue.main)
            .assign(to: \.image, on: blurhashImageView)
            .store(in: &_disposeBag)
        blurhashImageView.alpha = configuration.isReveal ? 0 : 1
        
        configuration.$isReveal
            .dropFirst()
            .removeDuplicates()
            .receive(on: DispatchQueue.main)
            .sink { [weak self] isReveal in
                guard let self = self else { return }
                let animator = UIViewPropertyAnimator(duration: 0.3, curve: .easeInOut)
                animator.addAnimations {
                    self.blurhashImageView.alpha = isReveal ? 0 : 1
                }
                animator.startAnimation()
            }
            .store(in: &_disposeBag)
    }
    
    public func prepareForReuse() {
        _disposeBag.removeAll()
        
        // reset appearance
        alpha = 1
        
        // reset image
        imageView.removeFromSuperview()
        imageView.removeConstraints(imageView.constraints)
        imageView.af.cancelImageRequest()
        imageView.image = nil
        
        // reset player
        playerViewController.view.removeFromSuperview()
        playerViewController.contentOverlayView.flatMap { view in
            view.removeConstraints(view.constraints)
        }
        playerViewController.player?.pause()
        playerViewController.player = nil
        playerLooper = nil
        
        // blurhash
        blurhashImageView.removeFromSuperview()
        blurhashImageView.removeConstraints(blurhashImageView.constraints)
        blurhashImageView.image = nil
        
        // reset indicator
        indicatorBlurEffectView.removeFromSuperview()
        
        // reset container
        container.removeFromSuperview()
        container.removeConstraints(container.constraints)
        
        // reset configuration
        configuration = nil
    }
}

extension MediaView {
    private func setupGIFPlayer(info: Configuration.VideoInfo) -> AVPlayer? {
        guard let urlString = info.assetURL,
              let url = URL(string: urlString)
        else { return nil }
        let playerItem = AVPlayerItem(url: url)
        let player = AVQueuePlayer(playerItem: playerItem)
        player.isMuted = true
        return player
    }
    
    private func setupPlayerLooper(player: AVPlayer) {
        guard let queuePlayer = player as? AVQueuePlayer else { return }
        guard let templateItem = queuePlayer.items().first else { return }
        playerLooper = AVPlayerLooper(player: queuePlayer, templateItem: templateItem)
    }
    
    private func setupContainerViewHierarchy() {
        guard container.superview == nil else { return }
        container.translatesAutoresizingMaskIntoConstraints = false
        addSubview(container)
        NSLayoutConstraint.activate([
            container.topAnchor.constraint(equalTo: topAnchor),
            container.leadingAnchor.constraint(equalTo: leadingAnchor),
            container.trailingAnchor.constraint(equalTo: trailingAnchor),
            container.bottomAnchor.constraint(equalTo: bottomAnchor),
        ])
    }

    private func setupIndicatorViewHierarchy() {
        let blurEffectView = indicatorBlurEffectView
        let vibrancyEffectView = indicatorVibrancyEffectView
        
        assert(playerViewController.contentOverlayView != nil)
        if let contentOverlayView = playerViewController.contentOverlayView {
            blurEffectView.translatesAutoresizingMaskIntoConstraints = false
            contentOverlayView.addSubview(indicatorBlurEffectView)
            NSLayoutConstraint.activate([
                contentOverlayView.trailingAnchor.constraint(equalTo: blurEffectView.trailingAnchor, constant: 16),
                contentOverlayView.bottomAnchor.constraint(equalTo: blurEffectView.bottomAnchor, constant: 8),
            ])
        }

        if vibrancyEffectView.superview == nil {
            vibrancyEffectView.translatesAutoresizingMaskIntoConstraints = false
            blurEffectView.contentView.addSubview(vibrancyEffectView)
            NSLayoutConstraint.activate([
                vibrancyEffectView.topAnchor.constraint(equalTo: blurEffectView.contentView.topAnchor),
                vibrancyEffectView.leadingAnchor.constraint(equalTo: blurEffectView.contentView.leadingAnchor),
                vibrancyEffectView.trailingAnchor.constraint(equalTo: blurEffectView.contentView.trailingAnchor),
                vibrancyEffectView.bottomAnchor.constraint(equalTo: blurEffectView.contentView.bottomAnchor),
            ])
        }
        
        if playerIndicatorLabel.superview == nil {
            playerIndicatorLabel.translatesAutoresizingMaskIntoConstraints = false
            vibrancyEffectView.contentView.addSubview(playerIndicatorLabel)
            NSLayoutConstraint.activate([
                playerIndicatorLabel.topAnchor.constraint(equalTo: vibrancyEffectView.contentView.topAnchor),
                playerIndicatorLabel.leadingAnchor.constraint(equalTo: vibrancyEffectView.contentView.leadingAnchor, constant: 3),
                vibrancyEffectView.contentView.trailingAnchor.constraint(equalTo: playerIndicatorLabel.trailingAnchor, constant: 3),
                playerIndicatorLabel.bottomAnchor.constraint(equalTo: vibrancyEffectView.contentView.bottomAnchor),
            ])
        }
    }
}