Tusker/Tusker/Screens/Search/SearchResultsViewController.swift

//
//  SearchResultsViewController.swift
//  Tusker
//
//  Created by Shadowfacts on 9/14/19.
//  Copyright © 2019 Shadowfacts. All rights reserved.
//

import UIKit
import Combine
import Pachyderm

fileprivate let accountCell = "accountCell"
fileprivate let statusCell = "statusCell"
fileprivate let hashtagCell = "hashtagCell"

protocol SearchResultsViewControllerDelegate: AnyObject {
    func selectedSearchResult(account accountID: String)
    func selectedSearchResult(hashtag: Hashtag)
    func selectedSearchResult(status statusID: String)
}

extension SearchResultsViewControllerDelegate {
    func selectedSearchResult(account accountID: String) {}
    func selectedSearchResult(hashtag: Hashtag) {}
    func selectedSearchResult(status statusID: String) {}
}

class SearchResultsViewController: EnhancedTableViewController {

    weak var mastodonController: MastodonController!
    
    weak var exploreNavigationController: UINavigationController?
    weak var delegate: SearchResultsViewControllerDelegate?
    
    var dataSource: UITableViewDiffableDataSource<Section, Item>!

    private var activityIndicator: UIActivityIndicatorView!
    private var errorLabel: UILabel!
    
    /// Types of results to search for.
    var scope: Scope
    /// Whether to limit results to accounts the users is following.
    var following: Bool? = nil
    
    let searchSubject = PassthroughSubject<String?, Never>()
    var currentQuery: String?
    
    init(mastodonController: MastodonController, scope: Scope = .all) {
        self.mastodonController = mastodonController
        self.scope = scope

        super.init(style: .grouped)
        
        dragEnabled = true
        
        title = NSLocalizedString("Search", comment: "search screen title")
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        errorLabel = UILabel()
        errorLabel.translatesAutoresizingMaskIntoConstraints = false
        errorLabel.font = .preferredFont(forTextStyle: .callout)
        errorLabel.textColor = .secondaryLabel
        errorLabel.numberOfLines = 0
        errorLabel.textAlignment = .center
        errorLabel.setContentHuggingPriority(.defaultLow, for: .horizontal)
        tableView.addSubview(errorLabel)
        NSLayoutConstraint.activate([
            errorLabel.centerYAnchor.constraint(equalTo: view.safeAreaLayoutGuide.centerYAnchor),
            errorLabel.centerXAnchor.constraint(equalTo: tableView.centerXAnchor),
            errorLabel.leadingAnchor.constraint(equalToSystemSpacingAfter: tableView.leadingAnchor, multiplier: 1),
            tableView.trailingAnchor.constraint(equalToSystemSpacingAfter: errorLabel.trailingAnchor, multiplier: 1),
        ])

        tableView.register(UINib(nibName: "AccountTableViewCell", bundle: .main), forCellReuseIdentifier: accountCell)
        tableView.register(UINib(nibName: "TimelineStatusTableViewCell", bundle: .main), forCellReuseIdentifier: statusCell)
        tableView.register(UINib(nibName: "HashtagTableViewCell", bundle: .main), forCellReuseIdentifier: hashtagCell)
        
        tableView.allowsFocus = true
        tableView.backgroundColor = .appGroupedBackground
        
        dataSource = DataSource(tableView: tableView, cellProvider: { (tableView, indexPath, item) -> UITableViewCell? in
            let cell: UITableViewCell
            switch item {
            case let .account(id):
                let accountCell = tableView.dequeueReusableCell(withIdentifier: accountCell, for: indexPath) as! AccountTableViewCell
                accountCell.delegate = self
                accountCell.updateUI(accountID: id)
                cell = accountCell
            case let .hashtag(tag):
                let hashtagCell = tableView.dequeueReusableCell(withIdentifier: hashtagCell, for: indexPath) as! HashtagTableViewCell
                hashtagCell.delegate = self
                hashtagCell.updateUI(hashtag: tag)
                cell = hashtagCell
            case let .status(id, state):
                let statusCell = tableView.dequeueReusableCell(withIdentifier: statusCell, for: indexPath) as! TimelineStatusTableViewCell
                statusCell.delegate = self
                statusCell.updateUI(statusID: id, state: state)
                cell = statusCell
            }
            cell.configurationUpdateHandler = { cell, state in
                var config = UIBackgroundConfiguration.listGroupedCell().updated(for: state)
                if state.isHighlighted || state.isSelected {
                    config.backgroundColor = .appSelectedCellBackground
                } else {
                    config.backgroundColor = .appGroupedCellBackground
                }
                cell.backgroundConfiguration = config
            }
            return cell
        })
        
        activityIndicator = UIActivityIndicatorView(style: .large)
        activityIndicator.translatesAutoresizingMaskIntoConstraints = false
        activityIndicator.isHidden = true
        view.addSubview(activityIndicator)
        NSLayoutConstraint.activate([
            activityIndicator.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            activityIndicator.topAnchor.constraint(equalTo: view.topAnchor, constant: 8)
        ])

        _ = searchSubject
            .debounce(for: .milliseconds(500), scheduler: RunLoop.main)
            .map { $0?.trimmingCharacters(in: .whitespacesAndNewlines) }
            .filter { $0 != self.currentQuery }
            .sink(receiveValue: performSearch(query:))

        userActivity = UserActivityManager.searchActivity()
        
        NotificationCenter.default.addObserver(self, selector: #selector(handleStatusDeleted), name: .statusDeleted, object: nil)
    }
    
    override func targetViewController(forAction action: Selector, sender: Any?) -> UIViewController? {
        // if we're showing a view controller, we need to go up to the explore VC's nav controller
        // the UISearchController that is our parent is not part of the normal VC hierarchy and itself doesn't have a parent
        if action == #selector(UIViewController.show(_:sender:)),
            let exploreNavController = exploreNavigationController {
            return exploreNavController
        }
        return super.targetViewController(forAction: action, sender: sender)
    }
    
    func loadResults(from source: SearchResultsViewController) {
        currentQuery = source.currentQuery
        if let sourceDataSource = source.dataSource {
            dataSource.apply(sourceDataSource.snapshot())
        }
    }
    
    func performSearch(query: String?) {
        guard let query = query, !query.isEmpty else {
            self.dataSource.apply(NSDiffableDataSourceSnapshot<Section, Item>())
            return
        }
        self.currentQuery = query

        activityIndicator.isHidden = false
        activityIndicator.startAnimating()
        errorLabel.isHidden = true

        let request = Client.search(query: query, types: scope.resultTypes, resolve: true, limit: 10, following: following)
        mastodonController.run(request) { (response) in
            switch response {
            case let .success(results, _):
                guard self.currentQuery == query else { return }
                DispatchQueue.main.async {
                    self.activityIndicator.isHidden = true
                    self.activityIndicator.stopAnimating()
                }
                self.showSearchResults(results)
            case let .failure(error):
                DispatchQueue.main.async {
                    self.activityIndicator.isHidden = true
                    self.activityIndicator.stopAnimating()

                    self.showSearchError(error)
                }
            }
        }
    }
    
    private func showSearchResults(_ results: SearchResults) {
        var snapshot = NSDiffableDataSourceSnapshot<Section, Item>()
        
        self.mastodonController.persistentContainer.performBatchUpdates({ (context, addAccounts, addStatuses) in
            let resultTypes = self.scope.resultTypes
            if !results.accounts.isEmpty && resultTypes.contains(.accounts) {
                snapshot.appendSections([.accounts])
                snapshot.appendItems(results.accounts.map { .account($0.id) }, toSection: .accounts)
                addAccounts(results.accounts)
            }
            if !results.hashtags.isEmpty && resultTypes.contains(.hashtags) {
                snapshot.appendSections([.hashtags])
                snapshot.appendItems(results.hashtags.map { .hashtag($0) }, toSection: .hashtags)
            }
            if !results.statuses.isEmpty && resultTypes.contains(.statuses) {
                snapshot.appendSections([.statuses])
                snapshot.appendItems(results.statuses.map { .status($0.id, .unknown) }, toSection: .statuses)
                addStatuses(results.statuses)
            }
        }, completion: {
            DispatchQueue.main.async {
                self.errorLabel.isHidden = true
                self.dataSource.apply(snapshot)
            }
        })
    }
    
    private func showSearchError(_ error: Client.Error) {
        let snapshot = NSDiffableDataSourceSnapshot<Section, Item>()
        dataSource.apply(snapshot)
        
        errorLabel.isHidden = false
        errorLabel.text = error.localizedDescription
    }
    
    @objc private func handleStatusDeleted(_ notification: Foundation.Notification) {
        guard let userInfo = notification.userInfo,
              let accountID = mastodonController.accountInfo?.id,
              userInfo["accountID"] as? String == accountID,
              let statusIDs = userInfo["statusIDs"] as? [String] else {
            return
        }
        var snapshot = self.dataSource.snapshot()
        let toDelete = statusIDs
            .map { id in
                Item.status(id, .unknown)
            }
            .filter { item in
                snapshot.itemIdentifiers.contains(item)
            }
        if !toDelete.isEmpty {
            snapshot.deleteItems(toDelete)
            self.dataSource.apply(snapshot, animatingDifferences: true)
        }
    }

    
    // MARK: - Table view delegate
    
    override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        if let delegate = delegate {
            switch dataSource.itemIdentifier(for: indexPath) {
            case nil:
                return
            case let .account(id):
                delegate.selectedSearchResult(account: id)
            case let .hashtag(hashtag):
                delegate.selectedSearchResult(hashtag: hashtag)
            case let .status(id, _):
                delegate.selectedSearchResult(status: id)
            }
        } else {
            super.tableView(tableView, didSelectRowAt: indexPath)
        }
    }

}

extension SearchResultsViewController {
    enum Scope: CaseIterable {
        case all
        case people
        case hashtags
        case posts
        
        var title: String {
            switch self {
            case .all:
                return "All"
            case .people:
                return "People"
            case .hashtags:
                return "Hashtags"
            case .posts:
                return "Posts"
            }
        }
        
        var resultTypes: [SearchResultType] {
            switch self {
            case .all:
                return [.accounts, .statuses, .hashtags]
            case .people:
                return [.accounts]
            case .hashtags:
                return [.hashtags]
            case .posts:
                return [.statuses]
            }
        }
    }
}

extension SearchResultsViewController {
    enum Section: CaseIterable {
        case accounts
        case hashtags
        case statuses

        var displayName: String {
            switch self {
            case .accounts:
                return NSLocalizedString("People", comment: "accounts search results section")
            case .hashtags:
                return NSLocalizedString("Hashtags", comment: "hashtag search results section")
            case .statuses:
                return NSLocalizedString("Posts", comment: "statuses search results section")
            }
        }
    }
    enum Item: Hashable {
        case account(String)
        case hashtag(Hashtag)
        case status(String, CollapseState)
        
        func hash(into hasher: inout Hasher) {
            switch self {
            case let .account(id):
                hasher.combine("account")
                hasher.combine(id)
            case let .hashtag(hashtag):
                hasher.combine("hashtag")
                hasher.combine(hashtag.url)
            case let .status(id, _):
                hasher.combine("status")
                hasher.combine(id)
            }
        }
    }
    
    class DataSource: UITableViewDiffableDataSource<Section, Item> {
        override func tableView(_ tableView: UITableView, titleForHeaderInSection sectionIndex: Int) -> String? {
            let currentSnapshot = snapshot()
            for section in Section.allCases where currentSnapshot.indexOfSection(section) == sectionIndex {
                return section.displayName
            }
            return nil
        }
    }
}

extension SearchResultsViewController: UISearchResultsUpdating {
    func updateSearchResults(for searchController: UISearchController) {
        searchSubject.send(searchController.searchBar.text)
    }
}

extension SearchResultsViewController: UISearchBarDelegate {
    func searchBarTextDidEndEditing(_ searchBar: UISearchBar) {
        // perform a search immedaitely when the search button is pressed
        performSearch(query: searchBar.text?.trimmingCharacters(in: .whitespacesAndNewlines))
    }
    
    func searchBar(_ searchBar: UISearchBar, selectedScopeButtonIndexDidChange selectedScope: Int) {
        self.scope = Scope.allCases[selectedScope]
        performSearch(query: searchBar.text?.trimmingCharacters(in: .whitespacesAndNewlines))
    }
}

extension SearchResultsViewController: TuskerNavigationDelegate {
    var apiController: MastodonController! { mastodonController }
}

extension SearchResultsViewController: ToastableViewController {
}

extension SearchResultsViewController: MenuActionProvider {
}

extension SearchResultsViewController: StatusTableViewCellDelegate {
    func statusCellCollapsedStateChanged(_ cell: BaseStatusTableViewCell) {
        tableView.beginUpdates()
        tableView.endUpdates()
    }
}