//
//  StatusUpdatedNotificationTableViewCell.swift
//  Tusker
//
//  Created by Shadowfacts on 11/27/22.
//  Copyright © 2022 Shadowfacts. All rights reserved.
//

import UIKit
import Pachyderm
import SwiftSoup

class StatusUpdatedNotificationTableViewCell: UITableViewCell {
    
    weak var delegate: (TuskerNavigationDelegate & MenuActionProvider)?

    @IBOutlet weak var timestampLabel: UILabel!
    @IBOutlet weak var displayNameLabel: EmojiLabel!
    @IBOutlet weak var contentLabel: UILabel!
    
    private var notification: Pachyderm.Notification?
    private var updateTimestampWorkItem: DispatchWorkItem?
    
    override func awakeFromNib() {
        super.awakeFromNib()
        
        timestampLabel.font = UIFont(descriptor: .preferredFontDescriptor(withTextStyle: .body).addingAttributes([
            .traits: [
                UIFontDescriptor.TraitKey.weight: UIFont.Weight.light.rawValue,
            ]
        ]), size: 0)
        timestampLabel.adjustsFontForContentSizeCategory = true

        displayNameLabel.font = .preferredFont(forTextStyle: .body).withTraits(.traitBold)!
        displayNameLabel.adjustsFontForContentSizeCategory = true
    }
    
    func updateUI(notification: Pachyderm.Notification) {
        guard notification.kind == .update,
              let status = notification.status else {
            return
        }
        
        self.notification = notification
        
        updateTimestamp()
        
        displayNameLabel.text = notification.account.displayName
        displayNameLabel.setEmojis(notification.account.emojis, identifier: notification.account.id)
        
        let doc = try! SwiftSoup.parseBodyFragment(status.content)
        contentLabel.text = try! doc.text()
    }
    
    private func updateTimestamp() {
        guard let notification else { return }
        
        timestampLabel.text = notification.createdAt.timeAgoString()
        
        let delay: DispatchTimeInterval?
        switch notification.createdAt.timeAgo().1 {
        case .second:
            delay = .seconds(10)
        case .minute:
            delay = .seconds(60)
        default:
            delay = nil
        }
        if let delay = delay {
            if updateTimestampWorkItem == nil {
                updateTimestampWorkItem = DispatchWorkItem { [weak self] in
                    self?.updateTimestamp()
                }
                DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: updateTimestampWorkItem!)
            }
        } else {
            updateTimestampWorkItem = nil
        }
    }
    
    override func prepareForReuse() {
        super.prepareForReuse()
        
        updateTimestampWorkItem?.cancel()
        updateTimestampWorkItem = nil
    }
    
}

extension StatusUpdatedNotificationTableViewCell: SelectableTableViewCell {
    func didSelectCell() {
        guard let delegate,
        let status = notification?.status else {
            return
        }
        let vc = delegate.conversation(mainStatusID: status.id, state: .unknown)
        delegate.show(vc)
    }
}

extension StatusUpdatedNotificationTableViewCell: MenuPreviewProvider {
    func getPreviewProviders(for location: CGPoint, sourceViewController: UIViewController) -> PreviewProviders? {
        guard let delegate,
              let statusID = notification?.status?.id,
              let status = delegate.apiController.persistentContainer.status(for: statusID) else {
            return nil
        }
        return (content: {
            delegate.conversation(mainStatusID: statusID, state: .unknown)
        }, actions: {
            delegate.actionsForStatus(status, source: .view(self))
        })
    }
}