MainFeedCollectionViewController.swift

//
//  MainFeedCollectionViewController.swift
//  NetNewsWire-iOS
//
//  Created by Stuart Breckenridge on 23/06/2025.
//  Copyright © 2025 Ranchero Software. All rights reserved.
//

import UIKit
import os
import SafariServices
import UniformTypeIdentifiers
import WebKit
import RSCore
import RSTree
import RSWeb
import Account
import Articles

private let reuseIdentifier = "FeedCell"
private let folderIdentifier = "Folder"
private let containerReuseIdentifier = "Container"

final class MainFeedCollectionViewController: UICollectionViewController, UndoableCommandRunner {
	@IBOutlet var filterButton: UIBarButtonItem!
	@IBOutlet var addNewItemButton: UIBarButtonItem! {
		didSet {
			addNewItemButton.target = self
			addNewItemButton.action = #selector(MainFeedCollectionViewController.add(_:))
		}
	}

	private static let logger = Logger(subsystem: Bundle.main.bundleIdentifier!, category: "MainFeedCollectionViewController")

	private let keyboardManager = KeyboardManager(type: .sidebar)
	override var keyCommands: [UIKeyCommand]? {

		// If the first responder is the WKWebView (PreloadedWebView) we don't want to supply any keyboard
		// commands that the system is looking for by going up the responder chain. They will interfere with
		// the WKWebViews built in hardware keyboard shortcuts, specifically the up and down arrow keys.
		guard let current = UIResponder.currentFirstResponder, !(current is PreloadedWebView) else {
			return nil
		}

		return keyboardManager.keyCommands
	}

	override var canBecomeFirstResponder: Bool {
		return true
	}

	var undoableCommands = [UndoableCommand]()
	weak var coordinator: SceneCoordinator!

	/// On iPhone, this property is used to prevent the user from selecting a new feed while the current feed is being deselected.
	/// While `isAnimating` is `true`, `shouldSelectItemAt()` will not allow new selection.
	/// The value is set to `true` in `viewWillAppear(_:)` if a feed is selected, and reset to `false` in
	/// `viewDidAppear(_:)` after a delay to allow the deselection animation to complete.
	private var isAnimating: Bool = false

	var dataSource: UICollectionViewDiffableDataSource<String, SidebarItemNode>!

	override func viewDidLoad() {
		super.viewDidLoad()
		registerForNotifications()
		configureCollectionView()
		configureDiffableDataSource()
		collectionView.dragDelegate = self
		collectionView.dropDelegate = self
		becomeFirstResponder()
    }

	override func viewWillAppear(_ animated: Bool) {
		Self.logger.debug("MainFeedCollectionViewController: viewWillAppear")
		navigationController?.isToolbarHidden = false
		updateUI()
		super.viewWillAppear(animated)

		if traitCollection.userInterfaceIdiom == .phone {
			self.navigationController?.navigationBar.prefersLargeTitles = true
			self.navigationItem.largeTitleDisplayMode = .always
			DispatchQueue.main.async {
				/// This sizes the navigation bar to large.
				self.navigationController?.navigationBar.sizeToFit()
			}

			/// On iPhone, we want to deselect the feed when the user navigates
			/// back to the feeds view. To prevent the user from selecting a new feed while
			/// the current feed is being deselected, set `isAnimating` to true.
			///
			/// `shouldSelectItemAt()` will not allow selection when `isAnimating`
			/// is `true.`
			if collectionView.indexPathsForSelectedItems != nil {
				isAnimating = true
			}
		}
	}

	override func viewDidAppear(_ animated: Bool) {
		super.viewDidAppear(animated)
		self.deselectIfNeccessary()
	}

	func deselectIfNeccessary() {
		guard traitCollection.userInterfaceIdiom == .phone else {
			return
		}

		defer {
			self.isAnimating = false
		}

		// Pro Max may have split view in landscape — give the device some
		// time to change its size class and then decide to deselect
		// <https://github.com/Ranchero-Software/NetNewsWire/issues/5043>
		DispatchQueue.main.asyncAfter(deadline: .now() + 0.1, execute: {
			// If the iPhone is in portrait, deselect.
			if UIDevice.current.orientation.isPortrait {
				if self.collectionView.indexPathsForSelectedItems != nil {
					self.coordinator.selectSidebarItem(indexPath: nil, animations: [.select])
				}
				return
			}

			// If the iPhone is in landscape, and the horizontal
			// size class is compact, deselect.
			if self.view.window?.traitCollection.horizontalSizeClass == .compact {
				if self.collectionView.indexPathsForSelectedItems != nil { self.coordinator.selectSidebarItem(indexPath: nil, animations: [.select])
				}
				return
			}
		})
	}

	func registerForNotifications() {
		NotificationCenter.default.addObserver(self, selector: #selector(unreadCountDidChange(_:)), name: .UnreadCountDidChange, object: nil)
		NotificationCenter.default.addObserver(self, selector: #selector(faviconDidBecomeAvailable(_:)), name: .FaviconDidBecomeAvailable, object: nil)
		// TODO: fix this temporary hack, which will probably require refactoring image handling.
		// We want to know when to possibly reconfigure our cells with a new image, and we don’t
		// always know when an image is available — but watching the .htmlMetadataAvailable Notification
		// lets us know that it’s time to request an image.
		NotificationCenter.default.addObserver(self, selector: #selector(faviconDidBecomeAvailable(_:)), name: .htmlMetadataAvailable, object: nil)
		NotificationCenter.default.addObserver(self, selector: #selector(feedIconDidBecomeAvailable(_:)), name: .feedIconDidBecomeAvailable, object: nil)
		NotificationCenter.default.addObserver(self, selector: #selector(feedSettingDidChange(_:)), name: .feedSettingDidChange, object: nil)

		registerForTraitChanges([UITraitPreferredContentSizeCategory.self], target: self, action: #selector(preferredContentSizeCategoryDidChange))
	}

	// MARK: - Collection View Configuration
	func configureCollectionView() {
		let standardCellLeadingOffSet = 48.0
		let indentedCellLeadingOffSet = 64.0
		let useSidebarAppearance = traitCollection.userInterfaceIdiom == .pad
		var config = UICollectionLayoutListConfiguration(appearance: useSidebarAppearance ? .sidebar : .insetGrouped)
		config.headerMode = .supplementary

		config.trailingSwipeActionsConfigurationProvider = { [unowned self] indexPath in
			if indexPath.section == 0 { return UISwipeActionsConfiguration(actions: []) }
			var actions = [UIContextualAction]()

			// Set up the delete action
			let deleteTitle = NSLocalizedString("Delete", comment: "Delete")
			let deleteAction = UIContextualAction(style: .destructive, title: nil) { [weak self] _, _, completion in
				self?.delete(indexPath: indexPath)
				completion(true)
			}
			deleteAction.image = UIImage(systemName: "trash")
			deleteAction.accessibilityLabel = deleteTitle
			deleteAction.backgroundColor = UIColor.systemRed
			actions.append(deleteAction)

			// Set up the rename action
			let renameTitle = NSLocalizedString("Rename", comment: "Rename")
			let renameAction = UIContextualAction(style: .normal, title: nil) { [weak self] _, _, completion in
				self?.rename(indexPath: indexPath)
				completion(true)
			}
			renameAction.backgroundColor = UIColor.systemOrange
			renameAction.image = UIImage(systemName: "pencil")
			renameAction.accessibilityLabel = renameTitle
			actions.append(renameAction)

			if let feed = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? Feed {
				let moreTitle = NSLocalizedString("More", comment: "More")
				let moreAction = UIContextualAction(style: .normal, title: nil) { [weak self] (action, view, completion) in

					if let self = self {

						let alert = UIAlertController(title: feed.nameForDisplay, message: nil, preferredStyle: .actionSheet)
						if let popoverController = alert.popoverPresentationController {
							popoverController.sourceView = view
							popoverController.sourceRect = CGRect(x: view.frame.size.width/2, y: view.frame.size.height/2, width: 1, height: 1)
						}

						if let action = self.getInfoAlertAction(indexPath: indexPath, completion: completion) {
							alert.addAction(action)
						}

						if let action = self.homePageAlertAction(indexPath: indexPath, completion: completion) {
							alert.addAction(action)
						}

						if let action = self.copyFeedPageAlertAction(indexPath: indexPath, completion: completion) {
							alert.addAction(action)
						}

						if let action = self.copyHomePageAlertAction(indexPath: indexPath, completion: completion) {
							alert.addAction(action)
						}

						if let action = self.markAllAsReadAlertAction(indexPath: indexPath, completion: completion) {
							alert.addAction(action)
						}

						if let action = self.markUnstarredAsReadAlertAction(indexPath: indexPath, completion: completion) {
							alert.addAction(action)
						}

						let cancelTitle = NSLocalizedString("Cancel", comment: "Cancel")
						alert.addAction(UIAlertAction(title: cancelTitle, style: .cancel) { _ in
							completion(true)
						})

						self.present(alert, animated: true)

					}

				}

				moreAction.backgroundColor = UIColor.systemGray
				moreAction.image = UIImage(systemName: "ellipsis")
				moreAction.accessibilityLabel = moreTitle
				actions.append(moreAction)
			}

			let config = UISwipeActionsConfiguration(actions: actions)
			config.performsFirstActionWithFullSwipe = false

			return config
		}

		config.itemSeparatorHandler = { (indexPath, sectionSeparatorConfiguration) in
			var configuration = sectionSeparatorConfiguration

			// Sidebar appearance: no separators
			if useSidebarAppearance {
				configuration.topSeparatorVisibility = .hidden
				configuration.bottomSeparatorVisibility = .hidden
				return configuration
			}

			// insetGrouped appearance: separators with proper insets
			configuration.bottomSeparatorVisibility = .hidden
			configuration.topSeparatorVisibility = indexPath.row == 0 ? .hidden : .visible

			if let cell = self.collectionView.cellForItem(at: indexPath) as? MainFeedCollectionViewCell {
				if cell.indentationLevel == 1 {
					configuration.topSeparatorInsets = NSDirectionalEdgeInsets(top: 0, leading: indentedCellLeadingOffSet, bottom: 0, trailing: 0)
				} else {
					configuration.topSeparatorInsets = NSDirectionalEdgeInsets(top: 0, leading: standardCellLeadingOffSet, bottom: 0, trailing: 0)
				}
			}
			if self.collectionView.cellForItem(at: indexPath) is MainFeedCollectionViewFolderCell {
				configuration.topSeparatorInsets = NSDirectionalEdgeInsets(top: 0, leading: standardCellLeadingOffSet, bottom: 0, trailing: 0)
			}
			return configuration
		}

		let layout = UICollectionViewCompositionalLayout.list(using: config)
		collectionView.setCollectionViewLayout(layout, animated: false)
		collectionView.refreshControl = UIRefreshControl()
		collectionView.refreshControl!.addTarget(self, action: #selector(refreshAccounts(_:)), for: .valueChanged)

		if config.appearance == .sidebar {
			// This defrosts the glass.
			collectionView.backgroundColor = .clear
		}
	}

	func configureDiffableDataSource() {
		dataSource = UICollectionViewDiffableDataSource<String, SidebarItemNode>(
			collectionView: collectionView
		) { [weak self] collectionView, indexPath, sidebarItemNode -> UICollectionViewCell? in
			guard let self else {
				return nil
			}

			if sidebarItemNode.node.representedObject is Folder {
				let cell = collectionView.dequeueReusableCell(
					withReuseIdentifier: folderIdentifier,
					for: indexPath
				) as! MainFeedCollectionViewFolderCell
				self.configure(cell, sidebarItemNode: sidebarItemNode)
				cell.delegate = self
				return cell
			} else {
				let cell = collectionView.dequeueReusableCell(
					withReuseIdentifier: reuseIdentifier,
					for: indexPath
				) as! MainFeedCollectionViewCell
				self.configure(cell, sidebarItemNode: sidebarItemNode)
				return cell
			}
		}

		dataSource.supplementaryViewProvider = { [weak self] collectionView, kind, indexPath in
			guard let self else {
				return nil
			}
			guard kind == UICollectionView.elementKindSectionHeader else {
				return UICollectionReusableView()
			}

			let headerView = collectionView.dequeueReusableSupplementaryView(
				ofKind: kind,
				withReuseIdentifier: containerReuseIdentifier,
				for: indexPath
			) as! MainFeedCollectionHeaderReusableView

			headerView.delegate = self

			let sectionID = self.dataSource.snapshot().sectionIdentifiers[indexPath.section]

			// Smart feeds section
			if sectionID.isEmpty {
				headerView.sectionHeaderType = .smartFeeds
				headerView.headerTitle.text = SmartFeedsController.shared.nameForDisplay
				headerView.unreadCount = 0
				headerView.disclosureExpanded = self.coordinator.isExpanded(SmartFeedsController.shared)
				return headerView
			}

			// Accounts
			guard let account = AccountManager.shared.existingAccount(accountID: sectionID) else {
				return headerView
			}

			headerView.sectionHeaderType = .account(sectionID)
			headerView.headerTitle.text = account.nameForDisplay
			headerView.unreadCount = account.unreadCount
			headerView.disclosureExpanded = self.coordinator.isExpanded(account)
			headerView.addInteraction(UIContextMenuInteraction(delegate: self))

			return headerView
		}
	}

	func applySnapshot(_ snapshot: NSDiffableDataSourceSnapshot<String, SidebarItemNode>, animatingDifferences: Bool, completion: (() -> Void)? = nil) {
		dataSource.apply(snapshot, animatingDifferences: animatingDifferences) {
			completion?()
		}
	}

	@IBAction func settings(_ sender: UIBarButtonItem) {
		coordinator.showSettings()
	}

    // MARK: UICollectionViewDelegate

	override func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
		becomeFirstResponder()
		coordinator.selectSidebarItem(indexPath: indexPath, animations: [.navigation, .select, .scroll])
	}

    // MARK: UICollectionViewDelegate

    /*
    // Uncomment this method to specify if the specified item should be highlighted during tracking
    override func collectionView(_ collectionView: UICollectionView, shouldHighlightItemAt indexPath: IndexPath) -> Bool {
        return true
    }
    */

    // Uncomment this method to specify if the specified item should be selected
    override func collectionView(_ collectionView: UICollectionView, shouldSelectItemAt indexPath: IndexPath) -> Bool {
		if traitCollection.userInterfaceIdiom == .pad { return true }
		return !isAnimating
    }

	override func collectionView(_ collectionView: UICollectionView, shouldShowMenuForItemAt indexPath: IndexPath) -> Bool {
        return true
    }

    override func collectionView(_ collectionView: UICollectionView, canPerformAction action: Selector, forItemAt indexPath: IndexPath, withSender sender: Any?) -> Bool {
        return false
    }

    override func collectionView(_ collectionView: UICollectionView, performAction action: Selector, forItemAt indexPath: IndexPath, withSender sender: Any?) {

    }

	override func collectionView(_ collectionView: UICollectionView, contextMenuConfigurationForItemAt indexPath: IndexPath, point: CGPoint) -> UIContextMenuConfiguration? {
		guard let sidebarItem = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? SidebarItem else {
			return nil
		}
		if sidebarItem is Feed {
			return makeFeedContextMenu(indexPath: indexPath, includeDeleteRename: true)
		} else if sidebarItem is Folder {
			return makeFolderContextMenu(indexPath: indexPath)
		} else if sidebarItem is PseudoFeed {
			return makePseudoFeedContextMenu(indexPath: indexPath)
		} else {
			return nil
		}
	}

	// MARK: - Key Commands

	// MARK: - Keyboard shortcuts

	@objc func collapseAllExceptForGroupItems(_ sender: Any?) {
		coordinator.collapseAllFolders()
	}

	@objc func collapseSelectedRows(_ sender: Any?) {
		if let indexPath = coordinator.currentFeedIndexPath, let node = coordinator.nodeFor(indexPath) {
			coordinator.collapse(node)
			if let folder = collectionView.cellForItem(at: indexPath) as? MainFeedCollectionViewFolderCell {
				folder.disclosureExpanded = false
			}
		}
	}

	@objc override func delete(_ sender: Any?) {
		if let indexPath = coordinator.currentFeedIndexPath {
			delete(indexPath: indexPath)
		}
	}

	@objc func expandAll(_ sender: Any?) {
		coordinator.expandAllSectionsAndFolders()
	}

	@objc func expandSelectedRows(_ sender: Any?) {
		if let indexPath = coordinator.currentFeedIndexPath, let node = coordinator.nodeFor(indexPath) {
			coordinator.expand(node)
			if let folder = collectionView.cellForItem(at: indexPath) as? MainFeedCollectionViewFolderCell {
				folder.disclosureExpanded = true
			}
		}
	}

	@objc func markAllAsRead(_ sender: Any) {
		guard let indexPath = collectionView.indexPathsForSelectedItems?.first, let contentView = collectionView.cellForItem(at: indexPath)?.contentView else {
			return
		}

		let title = NSLocalizedString("Mark All as Read", comment: "Mark All as Read")
		MarkAsReadAlertController.confirm(self, coordinator: coordinator, confirmTitle: title, sourceType: contentView) { [weak self] in
			self?.coordinator.markAllAsReadInTimeline()
		}
	}

	@objc func navigateToTimeline(_ sender: Any?) {
		coordinator.navigateToTimeline()
	}

	@objc func openInBrowser(_ sender: Any?) {
		coordinator.showBrowserForCurrentFeed()
	}

	@objc func selectNextDown(_ sender: Any?) {
		coordinator.selectNextFeed()
	}

	@objc func selectNextUp(_ sender: Any?) {
		coordinator.selectPrevFeed()
	}

	@objc func showFeedInspector(_ sender: Any?) {
		coordinator.showFeedInspector()
	}

	// MARK: - API

	func focus() {
		becomeFirstResponder()
	}

	func updateUI() {
		if coordinator.isReadFeedsFiltered {
			setFilterButtonToActive()
		} else {
			setFilterButtonToInactive()
		}
		addNewItemButton?.isEnabled = !AccountManager.shared.activeAccounts.isEmpty

		configureContextMenu()
	}

	func updateFeedSelection(animations: Animations) {
		if let indexPath = coordinator.currentFeedIndexPath {
			collectionView.selectItemAndScrollIfNotVisible(at: indexPath, animations: animations)
		} else {
			if let indexPath = collectionView.indexPathsForSelectedItems?.first {
				if animations.contains(.select) {
					collectionView.deselectItem(at: indexPath, animated: true)
				} else {
					collectionView.deselectItem(at: indexPath, animated: false)
				}
			}
		}
	}

	func openInAppBrowser() {
		if let indexPath = coordinator.currentFeedIndexPath,
			let url = coordinator.homePageURLForFeed(indexPath) {
			let vc = SFSafariViewController(url: url)
			vc.modalPresentationStyle = .overFullScreen
			present(vc, animated: true)
		}
	}

	func applyToAvailableCells(_ completion: (MainFeedCollectionViewCell, IndexPath) -> Void) {
		for cell in collectionView.visibleCells {
			guard let indexPath = collectionView.indexPath(for: cell) else {
				continue
			}
			if let cell = collectionView.cellForItem(at: indexPath) as? MainFeedCollectionViewCell {
				completion(cell, indexPath)
			}
		}
	}

	func configureIcon(_ cell: MainFeedCollectionViewCell, sidebarItem: SidebarItem) {
		guard let sidebarItemID = sidebarItem.sidebarItemID else {
			return
		}
		cell.iconImage = IconImageCache.shared.imageFor(sidebarItemID)
	}

	func configureIcon(_ cell: MainFeedCollectionViewFolderCell, sidebarItem: SidebarItem) {
		guard let sidebarItemID = sidebarItem.sidebarItemID else {
			return
		}
		cell.iconImage = IconImageCache.shared.imageFor(sidebarItemID)
	}

	func configureIcon(_ cell: MainFeedCollectionViewCell, _ indexPath: IndexPath) {
		guard let sidebarItemNode = dataSource.itemIdentifier(for: indexPath),
			  let sidebarItem = sidebarItemNode.node.representedObject as? SidebarItem,
			  let sidebarItemID = sidebarItem.sidebarItemID else {
			return
		}
		cell.iconImage = IconImageCache.shared.imageFor(sidebarItemID)
	}

	func configureIcon(_ cell: MainFeedCollectionViewFolderCell, _ indexPath: IndexPath) {
		guard let sidebarItemNode = dataSource.itemIdentifier(for: indexPath),
			  let sidebarItem = sidebarItemNode.node.representedObject as? SidebarItem,
			  let sidebarItemID = sidebarItem.sidebarItemID else {
			return
		}
		cell.iconImage = IconImageCache.shared.imageFor(sidebarItemID)
	}

	func configureCellsForRepresentedObject(_ representedObject: AnyObject) {
//		applyToCellsForRepresentedObject(representedObject, configure)
	}

	func applyToCellsForRepresentedObject(_ representedObject: AnyObject, _ completion: (MainFeedCollectionViewCell, IndexPath) -> Void) {
		applyToAvailableCells { (cell, indexPath) in
			guard let sidebarItemNode = dataSource.itemIdentifier(for: indexPath),
				  let representedSidebarItem = representedObject as? SidebarItem,
				  let candidateSidebarItem = sidebarItemNode.node.representedObject as? SidebarItem,
				  representedSidebarItem.sidebarItemID == candidateSidebarItem.sidebarItemID else {
				return
			}
			completion(cell, indexPath)
		}
	}

	func restoreSelectionIfNecessary(adjustScroll: Bool) {
		if let indexPath = coordinator.mainFeedIndexPathForCurrentTimeline() {
			if adjustScroll {
				collectionView.selectItemAndScrollIfNotVisible(at: indexPath, animations: [])
			} else {
				collectionView.selectItem(at: indexPath, animated: false, scrollPosition: .centeredVertically)
			}
		}
	}

	// MARK: - Private

	/// Configure feed cell.
	func configure(_ cell: MainFeedCollectionViewCell, sidebarItemNode: SidebarItemNode) {
		let node = sidebarItemNode.node
		var indentationLevel = 0
		if node.parent?.representedObject is Folder {
			indentationLevel = 1
		}

		if let sidebarItem = node.representedObject as? SidebarItem {
			cell.feedTitle.text = sidebarItem.nameForDisplay
			cell.unreadCount = sidebarItem.unreadCount
			cell.indentationLevel = indentationLevel
			configureIcon(cell, sidebarItem: sidebarItem)
		}
	}

	/// Configure folder cell.
	func configure(_ cell: MainFeedCollectionViewFolderCell, sidebarItemNode: SidebarItemNode) {
		let node = sidebarItemNode.node

		if let folder = node.representedObject as? Folder {
			cell.folderTitle.text = folder.nameForDisplay
			cell.unreadCount = folder.unreadCount
			configureIcon(cell, sidebarItem: folder)
		}

		if let containerID = (node.representedObject as? Container)?.containerID {
			cell.setDisclosure(isExpanded: coordinator.isExpanded(containerID), animated: false)
		}
	}

	private func findHeaderViewForAccount(_ account: Account) -> MainFeedCollectionHeaderReusableView? {
		guard let sectionIndex = dataSource.snapshot().sectionIdentifiers.firstIndex(of: account.accountID) else {
			return nil
		}
		guard sectionIndex > 0 else { // Skip smart feeds.
			return nil
		}

		return collectionView.supplementaryView(
			forElementKind: UICollectionView.elementKindSectionHeader,
			at: IndexPath(item: 0, section: sectionIndex))
		as? MainFeedCollectionHeaderReusableView
	}

	private func reloadAllVisibleCells() {
		let visibleIndexPaths = collectionView.indexPathsForVisibleItems
		let itemIdentifiers = visibleIndexPaths.compactMap { dataSource.itemIdentifier(for: $0) }
		reloadCells(itemIdentifiers) { [weak self] in
			self?.restoreSelectionIfNecessary(adjustScroll: false)
		}
	}

	private func reloadCells(_ items: [SidebarItemNode], completion: (() -> Void)? = nil) {
		guard !items.isEmpty else {
			completion?()
			return
		}

		var snapshot = dataSource.snapshot()
		snapshot.reloadItems(items)
		dataSource.apply(snapshot, animatingDifferences: false) {
			completion?()
		}
	}

	func setFilterButtonToActive() {
		filterButton.tintColor = Assets.Colors.primaryAccent
		filterButton?.accLabelText = NSLocalizedString("Selected - Filter Read Feeds", comment: "Selected - Filter Read Feeds")
	}

	func setFilterButtonToInactive() {
		filterButton.tintColor = nil
		filterButton?.accLabelText = NSLocalizedString("Filter Read Feeds", comment: "Filter Read Feeds")
	}

	// MARK: - Notifications

	@objc func preferredContentSizeCategoryDidChange() {
		IconImageCache.shared.emptyCache()
		reloadAllVisibleCells()
	}

	@objc func unreadCountDidChange(_ note: Notification) {
		updateUI()

		guard let unreadCountProvider = note.object as? UnreadCountProvider else {
			return
		}

		if let account = unreadCountProvider as? Account {
			if let headerView = findHeaderViewForAccount(account) {
				headerView.unreadCount = account.unreadCount
			}
			return
		}

		for cell in collectionView.visibleCells {
			guard let indexPath = collectionView.indexPath(for: cell),
				  let sidebarItemNode = dataSource.itemIdentifier(for: indexPath),
				  sidebarItemNode.node.representedObject === unreadCountProvider as AnyObject else {
				continue
			}
			if let feedCell = cell as? MainFeedCollectionViewCell {
				feedCell.unreadCount = unreadCountProvider.unreadCount
			}
			if let folderCell = cell as? MainFeedCollectionViewFolderCell {
				folderCell.unreadCount = unreadCountProvider.unreadCount
			}
		}
	}

	@objc func feedSettingDidChange(_ note: Notification) {
		guard let feed = note.object as? Feed, let key = note.userInfo?[Feed.SettingUserInfoKey] as? String else {
			return
		}
		if key == Feed.SettingKey.homePageURL || key == Feed.SettingKey.faviconURL {
			configureCellsForRepresentedObject(feed)
		}
	}

	@objc func faviconDidBecomeAvailable(_ note: Notification) {
		applyToAvailableCells(configureIcon)
	}

	@objc func feedIconDidBecomeAvailable(_ note: Notification) {
		guard let feed = note.userInfo?[UserInfoKey.feed] as? Feed else {
			return
		}
		applyToCellsForRepresentedObject(feed, configureIcon(_:_:))
	}

	// MARK: - Actions

	@objc func configureContextMenu(_: Any? = nil) {
		/*
			Context Menu Order:
			1. Add Feed
			2. Add Folder
		*/

		var menuItems: [UIAction] = []

		let addFeedActionTitle = NSLocalizedString("Add Feed", comment: "Add Feed")
		let addFeedAction = UIAction(title: addFeedActionTitle, image: Assets.Images.plus) { _ in
			self.coordinator.showAddFeed()
		}
		menuItems.append(addFeedAction)

		let addFolderActionTitle = NSLocalizedString("Add Folder", comment: "Add Folder")
		let addFolderAction = UIAction(title: addFolderActionTitle, image: Assets.Images.folderOutlinePlus) { _ in
			self.coordinator.showAddFolder()
		}

		menuItems.append(addFolderAction)

		let contextMenu = UIMenu(title: NSLocalizedString("Add Item", comment: "Add Item"), image: nil, identifier: nil, options: [], children: menuItems.reversed())

		self.addNewItemButton.menu = contextMenu
	}

	@objc func refreshAccounts(_ sender: Any) {
		collectionView.refreshControl?.endRefreshing()

		// This is a hack to make sure that an error dialog doesn't interfere with dismissing the refreshControl.
		// If the error dialog appears too closely to the call to endRefreshing, then the refreshControl never disappears.
		DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
			appDelegate.manualRefresh(errorHandler: ErrorHandler.present(self))
		}
	}

	@IBAction func add(_ sender: UIBarButtonItem) {
		let title = NSLocalizedString("Add Item", comment: "Add Item")
		let alertController = UIAlertController(title: title, message: nil, preferredStyle: .actionSheet)

		let cancelTitle = NSLocalizedString("Cancel", comment: "Cancel")
		let cancelAction = UIAlertAction(title: cancelTitle, style: .cancel)

		let addFeedActionTitle = NSLocalizedString("Add Feed", comment: "Add Feed")
		let addFeedAction = UIAlertAction(title: addFeedActionTitle, style: .default) { _ in
			self.coordinator.showAddFeed()
		}

		let addFolderActionTitle = NSLocalizedString("Add Folder", comment: "Add Folder")
		let addFolderAction = UIAlertAction(title: addFolderActionTitle, style: .default) { _ in
			self.coordinator.showAddFolder()
		}

		alertController.addAction(addFeedAction)

		alertController.addAction(addFolderAction)
		alertController.addAction(cancelAction)

		alertController.popoverPresentationController?.barButtonItem = sender

		present(alertController, animated: true)
	}

	@IBAction func toggleFilter(_ sender: Any) {
		coordinator.toggleReadFeedsFilter()
	}

	func toggle(_ headerView: MainFeedCollectionHeaderReusableView) {
		guard let sectionHeaderType = headerView.sectionHeaderType else {
			return
		}

		let containerID: ContainerIdentifier
		switch sectionHeaderType {
		case .smartFeeds:
			guard let id = SmartFeedsController.shared.containerID else {
				return
			}
			containerID = id
		case .account(let accountID):
			guard let account = AccountManager.shared.existingAccount(accountID: accountID),
				  let id = account.containerID else {
				return
			}
			containerID = id
		}

		if coordinator.isExpanded(containerID) {
			headerView.disclosureExpanded = false
			coordinator.collapse(containerID)
		} else {
			headerView.disclosureExpanded = true
			coordinator.expand(containerID)
		}
	}
}

extension MainFeedCollectionViewController: MainFeedCollectionHeaderReusableViewDelegate {
	func mainFeedCollectionHeaderReusableViewDidTapDisclosureIndicator(_ view: MainFeedCollectionHeaderReusableView) {
		toggle(view)
	}
}

extension MainFeedCollectionViewController: MainFeedCollectionViewFolderCellDelegate {
	func mainFeedCollectionFolderViewCellDisclosureDidToggle(_ sender: MainFeedCollectionViewFolderCell, expanding: Bool) {
		if expanding {
			expand(sender)
		} else {
			collapse(sender)
		}
	}

	func expand(_ cell: MainFeedCollectionViewFolderCell) {
		guard let indexPath = collectionView.indexPath(for: cell),
			  let node = dataSource.itemIdentifier(for: indexPath)?.node else {
			return
		}
		coordinator.expand(node)
	}

	func collapse(_ cell: MainFeedCollectionViewFolderCell) {
		guard let indexPath = collectionView.indexPath(for: cell),
			  let node = dataSource.itemIdentifier(for: indexPath)?.node else {
			return
		}
		coordinator.collapse(node)
	}
}

extension MainFeedCollectionViewController: UIContextMenuInteractionDelegate {
	func contextMenuInteraction(_ interaction: UIContextMenuInteraction, configurationForMenuAtLocation location: CGPoint) -> UIContextMenuConfiguration? {

		guard let headerView = interaction.view as? MainFeedCollectionHeaderReusableView,
			  case .account(let accountID) = headerView.sectionHeaderType,
			  let account = AccountManager.shared.existingAccount(accountID: accountID) else {
			return nil
		}

		return UIContextMenuConfiguration(identifier: accountID as NSCopying, previewProvider: nil) { _ in

			var menuElements = [UIMenuElement]()
			menuElements.append(UIMenu(title: "", options: .displayInline, children: [self.getAccountInfoAction(account: account)]))

			if let markAllAction = self.markAllAsReadAction(account: account, contentView: interaction.view) {
				menuElements.append(UIMenu(title: "", options: .displayInline, children: [markAllAction]))
			}

			if let markUnstarredAction = self.markUnstarredAsReadAction(account: account, contentView: interaction.view) {
				menuElements.append(UIMenu(title: "", options: .displayInline, children: [markUnstarredAction]))
			}

			menuElements.append(UIMenu(title: "", options: .displayInline, children: [self.deactivateAccountAction(account: account)]))

			return UIMenu(title: "", children: menuElements)
		}
	}

	func contextMenuInteraction(_ interaction: UIContextMenuInteraction, previewForHighlightingMenuWithConfiguration configuration: UIContextMenuConfiguration) -> UITargetedPreview? {

		guard let accountID = configuration.identifier as? String,
			  let sectionIndex = dataSource.snapshot().sectionIdentifiers.firstIndex(of: accountID),
			  let cell = collectionView.supplementaryView(forElementKind: UICollectionView.elementKindSectionHeader, at: IndexPath(item: 0, section: sectionIndex)) as? MainFeedCollectionHeaderReusableView else {
			return nil
		}
		return UITargetedPreview(view: cell, parameters: CroppingPreviewParameters(view: cell))
	}
}

extension MainFeedCollectionViewController {
	func makeFeedContextMenu(indexPath: IndexPath, includeDeleteRename: Bool) -> UIContextMenuConfiguration {
		return UIContextMenuConfiguration(identifier: MainFeedRowIdentifier(indexPath: indexPath), previewProvider: nil, actionProvider: { [ weak self] _ in

			guard let self = self else {
				return nil
			}

			var menuElements = [UIMenuElement]()

			if let inspectorAction = self.getInfoAction(indexPath: indexPath) {
				menuElements.append(UIMenu(title: "", options: .displayInline, children: [inspectorAction]))
			}

			if let homePageAction = self.homePageAction(indexPath: indexPath) {
				menuElements.append(UIMenu(title: "", options: .displayInline, children: [homePageAction]))
			}

			var pageActions = [UIAction]()
			if let copyFeedPageAction = self.copyFeedPageAction(indexPath: indexPath) {
				pageActions.append(copyFeedPageAction)
			}
			if let copyHomePageAction = self.copyHomePageAction(indexPath: indexPath) {
				pageActions.append(copyHomePageAction)
			}
			if !pageActions.isEmpty {
				menuElements.append(UIMenu(title: "", options: .displayInline, children: pageActions))
			}

			if let markAllAction = self.markAllAsReadAction(indexPath: indexPath) {
				menuElements.append(UIMenu(title: "", options: .displayInline, children: [markAllAction]))
			}

			if let markUnstarredAction = self.markUnstarredAsReadAction(indexPath: indexPath) {
				menuElements.append(UIMenu(title: "", options: .displayInline, children: [markUnstarredAction]))
			}

			if includeDeleteRename {
				menuElements.append(UIMenu(title: "",
										   options: .displayInline,
										   children: [
											self.renameAction(indexPath: indexPath),
											self.deleteAction(indexPath: indexPath)
										   ]))
			}

			return UIMenu(title: "", children: menuElements)
		})
	}

	func makeFolderContextMenu(indexPath: IndexPath) -> UIContextMenuConfiguration {
		return UIContextMenuConfiguration(identifier: MainFeedRowIdentifier(indexPath: indexPath), previewProvider: nil, actionProvider: { [weak self] _ in

			guard let self = self else {
				return nil
			}

			var menuElements = [UIMenuElement]()

			if let markAllAction = self.markAllAsReadAction(indexPath: indexPath) {
				menuElements.append(UIMenu(title: "", options: .displayInline, children: [markAllAction]))
			}

			if let markUnstarredAction = self.markUnstarredAsReadAction(indexPath: indexPath) {
				menuElements.append(UIMenu(title: "", options: .displayInline, children: [markUnstarredAction]))
			}

			menuElements.append(UIMenu(title: "",
									   options: .displayInline,
									   children: [
										self.renameAction(indexPath: indexPath),
										self.deleteAction(indexPath: indexPath)
									   ]))

			return UIMenu(title: "", children: menuElements)

		})
	}

	func makePseudoFeedContextMenu(indexPath: IndexPath) -> UIContextMenuConfiguration? {
		var actions = [UIAction]()

		if let markAllAction = self.markAllAsReadAction(indexPath: indexPath) {
			actions.append(markAllAction)
		}
		if let markUnstarredAction = self.markUnstarredAsReadAction(indexPath: indexPath) {
			actions.append(markUnstarredAction)
		}

		guard !actions.isEmpty else {
			return nil
		}

		return UIContextMenuConfiguration(identifier: MainFeedRowIdentifier(indexPath: indexPath), previewProvider: nil, actionProvider: { _ in
			return UIMenu(title: "", children: actions)
		})
	}

	func homePageAction(indexPath: IndexPath) -> UIAction? {
		guard let feed = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? Feed,
			  let homePageURL = feed.homePageURL,
			  let url = URL(string: homePageURL) else {
			return nil
		}

		let title = NSLocalizedString("Open Home Page", comment: "Open Home Page")
		let action = UIAction(title: title, image: Assets.Images.safari) { _ in
			UIApplication.shared.open(url, options: [:])
		}
		return action
	}

	func homePageAlertAction(indexPath: IndexPath, completion: @escaping (Bool) -> Void) -> UIAlertAction? {
		guard let feed = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? Feed,
			  let homePageURL = feed.homePageURL,
			  let url = URL(string: homePageURL) else {
			return nil
		}

		let title = NSLocalizedString("Open Home Page", comment: "Open Home Page")
		let action = UIAlertAction(title: title, style: .default) { _ in
			UIApplication.shared.open(url, options: [:])
			completion(true)
		}
		return action
	}

	func copyFeedPageAction(indexPath: IndexPath) -> UIAction? {
		guard let feed = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? Feed,
			  let url = URL(string: feed.url) else {
				  return nil
			  }

		let title = NSLocalizedString("Copy Feed URL", comment: "Copy Feed URL")
		let action = UIAction(title: title, image: Assets.Images.copy) { _ in
			UIPasteboard.general.url = url
		}
		return action
	}

	func copyFeedPageAlertAction(indexPath: IndexPath, completion: @escaping (Bool) -> Void) -> UIAlertAction? {
		guard let feed = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? Feed,
			  let url = URL(string: feed.url) else {
				  return nil
			  }

		let title = NSLocalizedString("Copy Feed URL", comment: "Copy Feed URL")
		let action = UIAlertAction(title: title, style: .default) { _ in
			UIPasteboard.general.url = url
			completion(true)
		}
		return action
	}

	func copyHomePageAction(indexPath: IndexPath) -> UIAction? {
		guard let feed = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? Feed,
			  let homePageURL = feed.homePageURL,
			  let url = URL(string: homePageURL) else {
				  return nil
			  }

		let title = NSLocalizedString("Copy Home Page URL", comment: "Copy Home Page URL")
		let action = UIAction(title: title, image: Assets.Images.copy) { _ in
			UIPasteboard.general.url = url
		}
		return action
	}

	func copyHomePageAlertAction(indexPath: IndexPath, completion: @escaping (Bool) -> Void) -> UIAlertAction? {
		guard let feed = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? Feed,
			  let homePageURL = feed.homePageURL,
			  let url = URL(string: homePageURL) else {
				  return nil
			  }

		let title = NSLocalizedString("Copy Home Page URL", comment: "Copy Home Page URL")
		let action = UIAlertAction(title: title, style: .default) { _ in
			UIPasteboard.general.url = url
			completion(true)
		}
		return action
	}

	func markAllAsReadAlertAction(indexPath: IndexPath, completion: @escaping (Bool) -> Void) -> UIAlertAction? {
		guard let feed = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? Feed,
			feed.unreadCount > 0,
			let articles = try? feed.fetchArticles(), let contentView = self.collectionView.cellForItem(at: indexPath)?.contentView else {
				return nil
		}

		let localizedMenuText = NSLocalizedString("Mark All as Read in “%@”", comment: "Command")
		let title = NSString.localizedStringWithFormat(localizedMenuText as NSString, feed.nameForDisplay) as String
		let cancel = {
			completion(true)
		}

		let action = UIAlertAction(title: title, style: .default) { [weak self] _ in
			MarkAsReadAlertController.confirm(self, coordinator: self?.coordinator, confirmTitle: title, sourceType: contentView, cancelCompletion: cancel) { [weak self] in
				self?.coordinator.markAllAsRead(Array(articles))
				completion(true)
			}
		}
		return action
	}

	func deleteAction(indexPath: IndexPath) -> UIAction {
		let title = NSLocalizedString("Delete", comment: "Delete")

		let action = UIAction(title: title, image: Assets.Images.trash, attributes: .destructive) { [weak self] _ in
			self?.delete(indexPath: indexPath)
		}
		return action
	}

	func renameAction(indexPath: IndexPath) -> UIAction {
		let title = NSLocalizedString("Rename", comment: "Rename")
		let action = UIAction(title: title, image: Assets.Images.edit) { [weak self] _ in
			self?.rename(indexPath: indexPath)
		}
		return action
	}

	func getInfoAction(indexPath: IndexPath) -> UIAction? {
		guard let feed = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? Feed else {
			return nil
		}

		let title = NSLocalizedString("Get Info", comment: "Get Info")
		let action = UIAction(title: title, image: Assets.Images.info) { [weak self] _ in
			self?.coordinator.showFeedInspector(for: feed)
		}
		return action
	}

	func getAccountInfoAction(account: Account) -> UIAction {
		let title = NSLocalizedString("Get Info", comment: "Get Info")
		let action = UIAction(title: title, image: Assets.Images.info) { [weak self] _ in
			self?.coordinator.showAccountInspector(for: account)
		}
		return action
	}

	func deactivateAccountAction(account: Account) -> UIAction {
		let title = NSLocalizedString("Deactivate", comment: "Deactivate")
		let action = UIAction(title: title, image: Assets.Images.deactivate) { _ in
			account.isActive = false
		}
		return action
	}

	func getInfoAlertAction(indexPath: IndexPath, completion: @escaping (Bool) -> Void) -> UIAlertAction? {
		guard let feed = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? Feed else {
			return nil
		}

		let title = NSLocalizedString("Get Info", comment: "Get Info")
		let action = UIAlertAction(title: title, style: .default) { [weak self] _ in
			self?.coordinator.showFeedInspector(for: feed)
			completion(true)
		}
		return action
	}

	func markAllAsReadAction(indexPath: IndexPath) -> UIAction? {
		guard let sidebarItem = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? SidebarItem,
			  let contentView = self.collectionView.cellForItem(at: indexPath)?.contentView,
			  sidebarItem.unreadCount > 0 else {
				  return nil
			  }

		let localizedMenuText = NSLocalizedString("Mark All as Read in “%@”", comment: "Command")
		let title = NSString.localizedStringWithFormat(localizedMenuText as NSString, sidebarItem.nameForDisplay) as String
		let action = UIAction(title: title, image: Assets.Images.markAllAsRead) { [weak self] _ in
			MarkAsReadAlertController.confirm(self, coordinator: self?.coordinator, confirmTitle: title, sourceType: contentView) { [weak self] in
				if let articles = try? sidebarItem.fetchUnreadArticles() {
					self?.coordinator.markAllAsRead(Array(articles))
				}
			}
		}

		return action
	}

	func markAllAsReadAction(account: Account, contentView: UIView?) -> UIAction? {
		guard account.unreadCount > 0, let contentView else {
			return nil
		}

		let localizedMenuText = NSLocalizedString("Mark All as Read in “%@”", comment: "Command")
		let title = NSString.localizedStringWithFormat(localizedMenuText as NSString, account.nameForDisplay) as String
		let action = UIAction(title: title, image: Assets.Images.markAllAsRead) { [weak self] _ in
			MarkAsReadAlertController.confirm(self, coordinator: self?.coordinator, confirmTitle: title, sourceType: contentView) { [weak self] in
				// If you don't have this delay the screen flashes when it executes this code
				DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
					if let articles = try? account.fetchArticles(.unread()) {
						self?.coordinator.markAllAsRead(Array(articles))
					}
				}
			}
		}

		return action
	}

	func markUnstarredAsReadAction(indexPath: IndexPath) -> UIAction? {
		guard let sidebarItem = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? SidebarItem,
			  let contentView = self.collectionView.cellForItem(at: indexPath)?.contentView,
			  sidebarItem.unreadCount > 0,
			  let articles = try? sidebarItem.fetchUnreadArticles(),
			  Array(articles).unreadUnstarredArticles() != nil else {
			return nil
		}

		let title = NSLocalizedString("Mark Unstarred as Read", comment: "Command")
		let action = UIAction(title: title, image: Assets.Images.markAllAsRead) { [weak self] _ in
			MarkAsReadAlertController.confirm(self, coordinator: self?.coordinator, confirmTitle: title, sourceType: contentView) { [weak self] in
				if let articles = try? sidebarItem.fetchUnreadArticles(),
				   let unstarred = Array(articles).unreadUnstarredArticles() {
					self?.coordinator.markAllAsRead(unstarred)
				}
			}
		}
		return action
	}

	func markUnstarredAsReadAction(account: Account, contentView: UIView?) -> UIAction? {
		guard account.unreadCount > 0, let contentView else {
			return nil
		}
		guard let articles = try? account.fetchArticles(.unread()),
			  Array(articles).unreadUnstarredArticles() != nil else {
			return nil
		}

		let title = NSLocalizedString("Mark Unstarred as Read", comment: "Command")
		let action = UIAction(title: title, image: Assets.Images.markAllAsRead) { [weak self] _ in
			MarkAsReadAlertController.confirm(self, coordinator: self?.coordinator, confirmTitle: title, sourceType: contentView) { [weak self] in
				DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
					if let articles = try? account.fetchArticles(.unread()),
					   let unstarred = Array(articles).unreadUnstarredArticles() {
						self?.coordinator.markAllAsRead(unstarred)
					}
				}
			}
		}
		return action
	}

	func markUnstarredAsReadAlertAction(indexPath: IndexPath, completion: @escaping (Bool) -> Void) -> UIAlertAction? {
		guard let feed = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? Feed,
			  feed.unreadCount > 0,
			  let articles = try? feed.fetchArticles(),
			  Array(articles).unreadUnstarredArticles() != nil,
			  let contentView = self.collectionView.cellForItem(at: indexPath)?.contentView else {
			return nil
		}

		let title = NSLocalizedString("Mark Unstarred as Read", comment: "Command")
		let cancel = {
			completion(true)
		}

		let action = UIAlertAction(title: title, style: .default) { [weak self] _ in
			MarkAsReadAlertController.confirm(self, coordinator: self?.coordinator, confirmTitle: title, sourceType: contentView, cancelCompletion: cancel) { [weak self] in
				if let articles = try? feed.fetchArticles(),
				   let unstarred = Array(articles).unreadUnstarredArticles() {
					self?.coordinator.markAllAsRead(unstarred)
				}
				completion(true)
			}
		}
		return action
	}

	func rename(indexPath: IndexPath) {
		guard let sidebarItem = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? SidebarItem else {
			return
		}

		let formatString = NSLocalizedString("Rename “%@”", comment: "Rename feed")
		let title = NSString.localizedStringWithFormat(formatString as NSString, sidebarItem.nameForDisplay) as String

		let alertController = UIAlertController(title: title, message: nil, preferredStyle: .alert)

		let cancelTitle = NSLocalizedString("Cancel", comment: "Cancel")
		alertController.addAction(UIAlertAction(title: cancelTitle, style: .cancel))

		let renameTitle = NSLocalizedString("Rename", comment: "Rename")
		let renameAction = UIAlertAction(title: renameTitle, style: .default) { [weak self] _ in

			guard let name = alertController.textFields?[0].text, !name.isEmpty else {
				return
			}

			if let feed = sidebarItem as? Feed {
				feed.rename(to: name) { result in
					switch result {
					case .success:
						break
					case .failure(let error):
						self?.presentError(error)
					}
				}
			} else if let folder = sidebarItem as? Folder {
				folder.rename(to: name) { result in
					switch result {
					case .success:
						break
					case .failure(let error):
						self?.presentError(error)
					}
				}
			}

		}

		alertController.addAction(renameAction)
		alertController.preferredAction = renameAction

		alertController.addTextField { textField in
			textField.text = sidebarItem.nameForDisplay
			textField.placeholder = NSLocalizedString("Name", comment: "Name")
			textField.clearButtonMode = .always
		}

		self.present(alertController, animated: true) {

		}

	}

	func delete(indexPath: IndexPath) {
		guard let sidebarItem = dataSource.itemIdentifier(for: indexPath)?.node.representedObject as? SidebarItem else {
			return
		}

		let title: String
		let message: String
		if sidebarItem is Folder {
			title = NSLocalizedString("Delete Folder", comment: "Delete folder")
			let localizedInformativeText = NSLocalizedString("Are you sure you want to delete the “%@” folder?", comment: "Folder delete text")
			message = NSString.localizedStringWithFormat(localizedInformativeText as NSString, sidebarItem.nameForDisplay) as String
		} else {
			title = NSLocalizedString("Delete Feed", comment: "Delete feed")
			let localizedInformativeText = NSLocalizedString("Are you sure you want to delete the “%@” feed?", comment: "Feed delete text")
			message = NSString.localizedStringWithFormat(localizedInformativeText as NSString, sidebarItem.nameForDisplay) as String
		}

		let alertController = UIAlertController(title: title, message: message, preferredStyle: .alert)

		let cancelTitle = NSLocalizedString("Cancel", comment: "Cancel")
		alertController.addAction(UIAlertAction(title: cancelTitle, style: .cancel))

		let deleteTitle = NSLocalizedString("Delete", comment: "Delete")
		let deleteAction = UIAlertAction(title: deleteTitle, style: .destructive) { [weak self] _ in
			self?.performDelete(indexPath: indexPath)
		}
		alertController.addAction(deleteAction)
		alertController.preferredAction = deleteAction

		self.present(alertController, animated: true)
	}

	func performDelete(indexPath: IndexPath) {
		guard let undoManager = undoManager,
			  let deleteNode = dataSource.itemIdentifier(for: indexPath)?.node,
			  let deleteCommand = DeleteCommand(nodesToDelete: [deleteNode], undoManager: undoManager, errorHandler: ErrorHandler.present(self)) else {
			return
		}

		if let folder = deleteNode.representedObject as? Folder {
			ActivityManager.cleanUp(folder)
		} else if let feed = deleteNode.representedObject as? Feed {
			ActivityManager.cleanUp(feed)
		}

		if indexPath == coordinator.currentFeedIndexPath {
			coordinator.selectSidebarItem(indexPath: nil)
		}

		pushUndoableCommand(deleteCommand)
		deleteCommand.perform()
	}
}