Tusker/Tusker/Views/Status/TimelineStatusCollectionViewCell.swift

//
//  TimelineStatusCollectionViewCell.swift
//  Tusker
//
//  Created by Shadowfacts on 10/1/22.
//  Copyright © 2022 Shadowfacts. All rights reserved.
//

import UIKit
import Pachyderm

class TimelineStatusCollectionViewCell: UICollectionViewListCell, StatusCollectionViewCell {
    
    // MARK: Subviews
    
    private lazy var reblogLabel = EmojiLabel().configure {
        $0.textColor = .secondaryLabel
        // this needs to have a higher priorty than the content container's zero height constraint
        $0.setContentHuggingPriority(.defaultHigh, for: .vertical)
        $0.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(reblogLabelPressed)))
    }
    
    private lazy var mainContainer = UIView().configure {
        avatarImageView.translatesAutoresizingMaskIntoConstraints = false
        $0.addSubview(avatarImageView)
        contentVStack.translatesAutoresizingMaskIntoConstraints = false
        $0.addSubview(contentVStack)
        metaIndicatorsView.translatesAutoresizingMaskIntoConstraints = false
        $0.addSubview(metaIndicatorsView)
        NSLayoutConstraint.activate([
            avatarImageView.leadingAnchor.constraint(equalTo: $0.leadingAnchor),
            avatarImageView.topAnchor.constraint(equalTo: $0.topAnchor),
            contentVStack.leadingAnchor.constraint(equalTo: avatarImageView.trailingAnchor, constant: 8),
            contentVStack.trailingAnchor.constraint(equalTo: $0.trailingAnchor),
            contentVStack.topAnchor.constraint(equalTo: $0.topAnchor),
            contentVStack.bottomAnchor.constraint(equalTo: $0.bottomAnchor),
            metaIndicatorsView.leadingAnchor.constraint(greaterThanOrEqualTo: $0.leadingAnchor),
            metaIndicatorsView.trailingAnchor.constraint(equalTo: avatarImageView.trailingAnchor),
            metaIndicatorsView.topAnchor.constraint(equalTo: avatarImageView.bottomAnchor, constant: 4),
        ])
    }
    
    private static let avatarImageViewSize: CGFloat = 50
    private(set) lazy var avatarImageView = CachedImageView(cache: .avatars).configure {
        $0.layer.masksToBounds = true
        NSLayoutConstraint.activate([
            $0.heightAnchor.constraint(equalToConstant: TimelineStatusCollectionViewCell.avatarImageViewSize),
            $0.widthAnchor.constraint(equalToConstant: TimelineStatusCollectionViewCell.avatarImageViewSize),
        ])
        $0.isUserInteractionEnabled = true
        $0.addInteraction(UIContextMenuInteraction(delegate: self))
        $0.addInteraction(UIDragInteraction(delegate: self))
        $0.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(accountPressed)))
    }
    
    private let metaIndicatorsView = StatusMetaIndicatorsView()
    
    private lazy var contentVStack = UIStackView(arrangedSubviews: [
        nameHStack,
        contentWarningLabel,
        collapseButton,
        contentContainer,
    ]).configure {
        $0.axis = .vertical
        $0.spacing = 4
        $0.alignment = .fill
    }
    
    private lazy var nameHStack = UIStackView(arrangedSubviews: [
        displayNameLabel,
        usernameLabel,
        pinImageView,
        timestampLabel,
    ]).configure {
        $0.axis = .horizontal
        $0.spacing = 4
        $0.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(accountPressed)))
    }
    
    let displayNameLabel = EmojiLabel().configure {
        $0.font = UIFont(descriptor: .preferredFontDescriptor(withTextStyle: .body).addingAttributes([
            .traits: [
                UIFontDescriptor.TraitKey.weight: UIFont.Weight.semibold.rawValue,
            ]
        ]), size: 0)
        $0.setContentHuggingPriority(.init(251), for: .horizontal)
        $0.setContentCompressionResistancePriority(.init(749), for: .horizontal)
    }
    
    let usernameLabel = UILabel().configure {
        $0.textColor = .secondaryLabel
        $0.font = UIFont(descriptor: .preferredFontDescriptor(withTextStyle: .body).addingAttributes([
            .traits: [
                UIFontDescriptor.TraitKey.weight: UIFont.Weight.light.rawValue,
            ]
        ]), size: 0)
        $0.setContentHuggingPriority(.init(249), for: .horizontal)
        $0.setContentCompressionResistancePriority(.init(748), for: .horizontal)
    }
    
    private let pinImageView = UIImageView(image: UIImage(systemName: "pin.fill")).configure {
        $0.tintColor = .secondaryLabel
        $0.setContentHuggingPriority(.init(251), for: .horizontal)
    }
    
    private let timestampLabel = UILabel().configure {
        $0.textColor = .secondaryLabel
        $0.font = UIFont(descriptor: .preferredFontDescriptor(withTextStyle: .body).addingAttributes([
            .traits: [
                UIFontDescriptor.TraitKey.weight: UIFont.Weight.light.rawValue,
            ]
        ]), size: 0)
    }
    
    private(set) lazy var contentWarningLabel = EmojiLabel().configure {
        $0.textColor = .secondaryLabel
        $0.font = UIFont(descriptor: .preferredFontDescriptor(withTextStyle: .body).addingAttributes([
            .traits: [
                UIFontDescriptor.TraitKey.weight: UIFont.Weight.bold.rawValue,
            ]
        ]), size: 0)
        // this needs to have a higher priorty than the content container's zero height constraint
        $0.setContentHuggingPriority(.defaultHigh, for: .vertical)
        $0.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(collapseButtonPressed)))
    }
    
    private(set) lazy var collapseButton = UIButton(configuration: {
        var config = UIButton.Configuration.filled()
        config.image = UIImage(systemName: "chevron.down")
        return config
    }()).configure {
        // this button is so big that dimming its background color is visually distracting
        $0.tintAdjustmentMode = .normal
        $0.setContentHuggingPriority(.defaultHigh, for: .vertical)
        $0.addTarget(self, action: #selector(collapseButtonPressed), for: .touchUpInside)
    }
    
    let contentContainer = StatusContentContainer().configure {
        $0.setContentHuggingPriority(.defaultLow, for: .vertical)
    }
    private var contentTextView: StatusContentTextView {
        contentContainer.contentTextView
    }
    private var cardView: StatusCardView {
        contentContainer.cardView
    }
    private var attachmentsView: AttachmentsContainerView {
        contentContainer.attachmentsView
    }
    private var pollView: StatusPollView {
        contentContainer.pollView
    }
    
    private var placeholderReplyButtonLeadingConstraint: NSLayoutConstraint!
    private lazy var actionsContainer = UIView().configure {
        replyButton.translatesAutoresizingMaskIntoConstraints = false
        $0.addSubview(replyButton)
        favoriteButton.translatesAutoresizingMaskIntoConstraints = false
        $0.addSubview(favoriteButton)
        reblogButton.translatesAutoresizingMaskIntoConstraints = false
        $0.addSubview(reblogButton)
        moreButton.translatesAutoresizingMaskIntoConstraints = false
        $0.addSubview(moreButton)
        placeholderReplyButtonLeadingConstraint = replyButton.leadingAnchor.constraint(equalTo: $0.leadingAnchor)
        NSLayoutConstraint.activate([
            favoriteButton.widthAnchor.constraint(equalTo: replyButton.widthAnchor),
            reblogButton.widthAnchor.constraint(equalTo: replyButton.widthAnchor),
            moreButton.widthAnchor.constraint(equalTo: replyButton.widthAnchor),
            
            // TODO: gah
            placeholderReplyButtonLeadingConstraint,
            replyButton.topAnchor.constraint(equalTo: $0.topAnchor),
            replyButton.bottomAnchor.constraint(equalTo: $0.bottomAnchor),
            
            favoriteButton.leadingAnchor.constraint(equalTo: replyButton.trailingAnchor),
            favoriteButton.topAnchor.constraint(equalTo: $0.topAnchor),
            favoriteButton.bottomAnchor.constraint(equalTo: $0.bottomAnchor),
            
            reblogButton.leadingAnchor.constraint(equalTo: favoriteButton.trailingAnchor),
            reblogButton.topAnchor.constraint(equalTo: $0.topAnchor),
            reblogButton.bottomAnchor.constraint(equalTo: $0.bottomAnchor),
            
            moreButton.leadingAnchor.constraint(equalTo: reblogButton.trailingAnchor),
            moreButton.trailingAnchor.constraint(equalTo: $0.trailingAnchor),
            moreButton.topAnchor.constraint(equalTo: $0.topAnchor),
            moreButton.bottomAnchor.constraint(equalTo: $0.bottomAnchor),
        ])
    }
    
    private(set) lazy var replyButton = UIButton().configure {
        $0.setImage(UIImage(systemName: "arrowshape.turn.up.left.fill"), for: .normal)
        $0.addTarget(self, action: #selector(replyPressed), for: .touchUpInside)
    }
    
    private(set) lazy var favoriteButton = UIButton().configure {
        $0.setImage(UIImage(systemName: "star.fill"), for: .normal)
        $0.addTarget(self, action: #selector(favoritePressed), for: .touchUpInside)
    }
    
    private(set) lazy var reblogButton = UIButton().configure {
        $0.setImage(UIImage(systemName: "repeat"), for: .normal)
        $0.addTarget(self, action: #selector(reblogPressed), for: .touchUpInside)
    }
    
    let moreButton = UIButton().configure {
        $0.setImage(UIImage(systemName: "ellipsis"), for: .normal)
        $0.showsMenuAsPrimaryAction = true
    }
    
    // MARK: Cell state
    
    private var mainContainerTopToReblogLabelConstraint: NSLayoutConstraint!
    private var mainContainerTopToSelfConstraint: NSLayoutConstraint!
    private var mainContainerBottomToActionsConstraint: NSLayoutConstraint!
    private var mainContainerBottomToSelfConstraint: NSLayoutConstraint!
    
    weak var mastodonController: MastodonController!
    weak var delegate: StatusCollectionViewCellDelegate?
    var showStatusAutomatically: Bool {
        // TODO: needed once conversation controller refactored
        false
    }
    var showReplyIndicator: Bool {
        // TODO: needed once conversation controller refactored
        false
    }
    var showPinned: Bool {
        // TODO: needed once profile controller refactored
        false
    }
    
    // alas these need to be internal so they're accessible from the protocol extensions
    var statusID: String!
    var statusState: StatusState!
    var accountID: String!
    private var reblogStatusID: String?
    private var rebloggerID: String?
    
    private var firstLayout = true
    var isGrayscale = false
    
    private var updateTimestampWorkItem: DispatchWorkItem?
 
    override init(frame: CGRect) {
        super.init(frame: frame)
        
        for subview in [reblogLabel, mainContainer, actionsContainer] {
            subview.translatesAutoresizingMaskIntoConstraints = false
            contentView.addSubview(subview)
        }
        
        mainContainerTopToReblogLabelConstraint = mainContainer.topAnchor.constraint(equalTo: reblogLabel.bottomAnchor, constant: 4)
        mainContainerTopToSelfConstraint = mainContainer.topAnchor.constraint(equalTo: contentView.topAnchor, constant: 8)
        mainContainerBottomToActionsConstraint = mainContainer.bottomAnchor.constraint(equalTo: actionsContainer.topAnchor)
        mainContainerBottomToSelfConstraint = mainContainer.bottomAnchor.constraint(equalTo: contentView.bottomAnchor, constant: -6)
        
        let metaIndicatorsBottomConstraint = metaIndicatorsView.bottomAnchor.constraint(lessThanOrEqualTo: contentView.bottomAnchor, constant: -6)
        // sometimes during intermediate layouts, there are conflicting constraints, so let this one get broken temporarily, to avoid a bunch of printing
        metaIndicatorsBottomConstraint.priority = .init(999)
        
        NSLayoutConstraint.activate([
            // why is this 4 but the mainContainerTopSelfConstraint constant 8? because this looks more balanced
            reblogLabel.topAnchor.constraint(equalTo: contentView.topAnchor, constant: 4),
            reblogLabel.leadingAnchor.constraint(equalTo: contentView.leadingAnchor, constant: 16),
            reblogLabel.trailingAnchor.constraint(equalTo: contentView.trailingAnchor, constant: -16),
            
            mainContainer.leadingAnchor.constraint(equalTo: contentView.leadingAnchor, constant: 16),
            mainContainer.trailingAnchor.constraint(equalTo: contentView.trailingAnchor, constant: -16),
            
            actionsContainer.leadingAnchor.constraint(equalTo: contentView.leadingAnchor, constant: 16),
            actionsContainer.trailingAnchor.constraint(equalTo: contentView.trailingAnchor, constant: -16),
            // yes, this is deliberately 6. 4 looks to cramped, 8 looks uneven
            actionsContainer.bottomAnchor.constraint(equalTo: contentView.bottomAnchor, constant: -6),
            
            metaIndicatorsBottomConstraint,
        ])
        
        updateActionsVisibility()
        
        NotificationCenter.default.addObserver(self, selector: #selector(preferencesChanged), name: .preferencesChanged, object: nil)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override func layoutSubviews() {
        super.layoutSubviews()
        
        if firstLayout {
            firstLayout = false
            
            // the button's image view doesn't exist until after the first layout
            // accessing it before that cause the button to layoutIfNeeded which generates a broken, intermediate layout and prints a bunch of unhelpful autolayout warnings
            // so we wait until after the first layout pass to setup the reply button's real constraint
            placeholderReplyButtonLeadingConstraint.isActive = false
            replyButton.imageView!.leadingAnchor.constraint(equalTo: contentTextView.leadingAnchor).isActive = true
        }
    }
    
    // MARK: Accessibility
    
    override var accessibilityLabel: String? {
        get {
            guard let status = mastodonController.persistentContainer.status(for: statusID) else {
                return nil
            }
            var str = "\(status.account.displayOrUserName), \(contentTextView.text ?? "")"
            
            if status.attachments.count > 0 {
                // TODO: localize me
                str += ", \(status.attachments.count) attachment\(status.attachments.count > 1 ? "s" : "")"
            }
            if status.poll != nil {
                str += ", poll"
            }
            str += ", \(status.createdAt.formatted(.relative(presentation: .numeric)))"
            if let rebloggerID,
               let reblogger = mastodonController.persistentContainer.account(for: rebloggerID) {
                str += ", reblogged by \(reblogger.displayOrUserName)"
            }
            return str
        }
        set {}
    }
    
    override func accessibilityActivate() -> Bool {
        delegate?.selected(status: statusID, state: statusState.copy())
        return true
    }
    
    // MARK: Configure UI
    
    func updateUI(statusID: String, state: StatusState) {
        guard var status = mastodonController.persistentContainer.status(for: statusID) else {
            fatalError()
        }
        
        self.statusState = state
        
        if let rebloggedStatus = status.reblog {
            reblogStatusID = statusID
            rebloggerID = status.account.id
            reblogLabel.isHidden = false
            mainContainerTopToReblogLabelConstraint.isActive = true
            mainContainerTopToSelfConstraint.isActive = false
            updateRebloggerLabel(reblogger: status.account)
            
            status = rebloggedStatus
        } else {
            reblogStatusID = nil
            rebloggerID = nil
            reblogLabel.isHidden = true
            mainContainerTopToReblogLabelConstraint.isActive = false
            mainContainerTopToSelfConstraint.isActive = true
        }
        
        doUpdateUI(status: status)
        
        doUpdateTimestamp(status: status)
        timestampLabel.isHidden = showPinned
        pinImageView.isHidden = !showPinned
    }
    
    func updateUIForPreferences(status: StatusMO) {
        baseUpdateUIForPreferences(status: status)
        
        if showReplyIndicator {
            metaIndicatorsView.allowedIndicators = .all
        } else {
            metaIndicatorsView.allowedIndicators = .all.subtracting(.reply)
        }
        
        if let rebloggerID,
           let reblogger = mastodonController.persistentContainer.account(for: rebloggerID) {
            updateRebloggerLabel(reblogger: reblogger)
        }
    }
    
    private func updateTimestamp() {
        guard let mastodonController,
              let status = mastodonController.persistentContainer.status(for: statusID) else {
            return
        }
        doUpdateTimestamp(status: status)
    }
    
    private func doUpdateTimestamp(status: StatusMO) {
        timestampLabel.text = status.createdAt.timeAgoString()
        
        let delay: DispatchTimeInterval?
        switch status.createdAt.timeAgo().1 {
        case .second:
            delay = .seconds(10)
        case .minute:
            delay = .seconds(60)
        default:
            delay = nil
        }
        if let delay {
            if updateTimestampWorkItem == nil {
                updateTimestampWorkItem = DispatchWorkItem { [weak self] in
                    self?.updateTimestamp()
                }
            }
            DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: updateTimestampWorkItem!)
        } else {
            updateTimestampWorkItem = nil
        }
    }
    
    private func updateRebloggerLabel(reblogger: AccountMO) {
        if Preferences.shared.hideCustomEmojiInUsernames {
            reblogLabel.text = "Reblogged by \(reblogger.displayNameWithoutCustomEmoji)"
            reblogLabel.removeEmojis()
        } else {
            reblogLabel.text = "Reblogged by \(reblogger.displayOrUserName)"
            reblogLabel.setEmojis(reblogger.emojis, identifier: reblogger.id)
        }
    }
    
    private func updateActionsVisibility() {
        if Preferences.shared.hideActionsInTimeline {
            actionsContainer.isHidden = true
            mainContainerBottomToSelfConstraint.isActive = true
            mainContainerBottomToActionsConstraint.isActive = false
        } else {
            actionsContainer.isHidden = false
            mainContainerBottomToSelfConstraint.isActive = false
            mainContainerBottomToActionsConstraint.isActive = true
        }
    }
    
    @objc private func preferencesChanged() {
        guard let mastodonController,
              let status = mastodonController.persistentContainer.status(for: statusID) else {
            return
        }
        
        updateUIForPreferences(status: status)
        
        if isGrayscale != Preferences.shared.grayscaleImages {
            updateGrayscaleableUI(status: status)
        }
        
        // only needs to happen when prefs change, rather than in updateUIForPrefs b/c this is setup correctly during init
        let oldState = actionsContainer.isHidden
        if oldState != Preferences.shared.hideActionsInTimeline {
            updateActionsVisibility()
            delegate?.statusCellNeedsReconfigure(self, animated: true)
        }
    }
    
    // MARK: Interaction
    
    @objc private func reblogLabelPressed() {
        guard let rebloggerID else {
            return
        }
        delegate?.selected(account: rebloggerID)
    }
    
    @objc private func accountPressed() {
        delegate?.selected(account: accountID)
    }
    
    @objc private func collapseButtonPressed() {
        toggleCollapse()
    }
    
    @objc private func replyPressed() {
        if Preferences.shared.mentionReblogger,
            let rebloggerID = rebloggerID,
            let rebloggerAccount = mastodonController.persistentContainer.account(for: rebloggerID) {
            delegate?.compose(inReplyToID: statusID, mentioningAcct: rebloggerAccount.acct)
        } else {
            delegate?.compose(inReplyToID: statusID)
        }
    }
    
    @objc private func favoritePressed() {
        toggleFavorite()
    }
    
    @objc private func reblogPressed() {
        toggleReblog()
    }
    
}

extension TimelineStatusCollectionViewCell: UIContextMenuInteractionDelegate {
    func contextMenuInteraction(_ interaction: UIContextMenuInteraction, configurationForMenuAtLocation location: CGPoint) -> UIContextMenuConfiguration? {
        return contextMenuConfigurationForAccount(sourceView: interaction.view!)
    }
    
    func contextMenuInteraction(_ interaction: UIContextMenuInteraction, willPerformPreviewActionForMenuWith configuration: UIContextMenuConfiguration, animator: UIContextMenuInteractionCommitAnimating) {
        if let delegate {
            MenuPreviewHelper.willPerformPreviewAction(animator: animator, presenter: delegate)
        }
    }
}

extension TimelineStatusCollectionViewCell: UIDragInteractionDelegate {
    func dragInteraction(_ interaction: UIDragInteraction, itemsForBeginning session: UIDragSession) -> [UIDragItem] {
        return dragItemsForAccount()
    }
}