Tusker/Tusker/Screens/Timeline/TimelineTableViewController.swift

//
//  StatusesTableViewController.swift
//  Tusker
//
//  Created by Shadowfacts on 8/15/18.
//  Copyright © 2018 Shadowfacts. All rights reserved.
//

import UIKit
import Pachyderm

class TimelineTableViewController: EnhancedTableViewController {
    
    var timeline: Timeline!
    weak var mastodonController: MastodonController!
    
    private var loaded = false
    
    var timelineSegments: [[(id: String, state: StatusState)]] = []
    
    var newer: RequestRange?
    var older: RequestRange?
    
    init(for timeline: Timeline, mastodonController: MastodonController) {
        self.timeline = timeline
        self.mastodonController = mastodonController
        
        super.init(style: .plain)
        
        title = timeline.title
        tabBarItem.image = timeline.tabBarImage

        self.refreshControl = UIRefreshControl()
        refreshControl!.addTarget(self, action: #selector(refreshStatuses(_:)), for: .valueChanged)
        
        userActivity = UserActivityManager.showTimelineActivity(timeline: timeline)
    }
    
    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    deinit {
        guard let persistentContainer = mastodonController?.persistentContainer else { return }
        // decrement reference counts of any statuses we still have
        // if the app is currently being quit, this will not affect the persisted data because
        // the persistent container would already have been saved in SceneDelegate.sceneDidEnterBackground(_:)
        for segment in timelineSegments {
            for (id, _) in segment {
                persistentContainer.status(for: id)?.decrementReferenceCount()
            }
        }
    }
    
    func statusID(for indexPath: IndexPath) -> String {
        return timelineSegments[indexPath.section][indexPath.row].id
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        tableView.rowHeight = UITableView.automaticDimension
        tableView.estimatedRowHeight = 140
        
        tableView.register(UINib(nibName: "TimelineStatusTableViewCell", bundle: nil), forCellReuseIdentifier: "statusCell")
        
        tableView.prefetchDataSource = self
    }
    
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        
        loadInitialStatuses()
    }
    
    func loadInitialStatuses() {
        guard !loaded else { return }
        loaded = true
        
        let request = Client.getStatuses(timeline: timeline)
        mastodonController.run(request) { response in
            guard case let .success(statuses, pagination) = response else { fatalError() }
            // todo: possible race condition here? we update the underlying data before waiting to reload the table view
            self.timelineSegments.insert(statuses.map { ($0.id, .unknown) }, at: 0)
            self.newer = pagination?.newer
            self.older = pagination?.older
            self.mastodonController.persistentContainer.addAll(statuses: statuses) {
                DispatchQueue.main.async {
                    self.tableView.reloadData()
                }
            }
        }
    }

    // MARK: - Table view data source

    override func numberOfSections(in tableView: UITableView) -> Int {
        return timelineSegments.count
    }

    override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return timelineSegments[section].count
    }

    
    override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        guard let cell = tableView.dequeueReusableCell(withIdentifier: "statusCell", for: indexPath) as? TimelineStatusTableViewCell else { fatalError() }

        let (id, state) = timelineSegments[indexPath.section][indexPath.row]
        cell.delegate = self

        cell.updateUI(statusID: id, state: state)

        return cell
    }
    
    // MARK: - Table view delegate
    
    override func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
        // don't remove rows when jumping to the top, otherwise jumping back down might try to show removed rows
        // when scrolling upwards, decrement reference counts for old statuses, if necessary
        if !isCurrentlyScrollingToTop, scrollViewDirection < 0 {
            if indexPath.section <= timelineSegments.count - 2 {
                // decrement ref counts for all sections below the section below the current section
                // (e.g., there exist sections 0, 1, 2 and we're currently scrolling upwards in section 0, we want to remove section 2)
                
                // todo: this is in the hot path for scrolling, possibly move this to a background thread?
                let sectionsToRemove = indexPath.section + 1..<timelineSegments.count
                for section in sectionsToRemove {
                    for (id, _) in timelineSegments.remove(at: section) {
                        mastodonController.persistentContainer.status(for: id)?.decrementReferenceCount()
                    }
                }
                // see below comment about DispatchQueue.main.async
                DispatchQueue.main.async {
                    UIView.performWithoutAnimation {
                        tableView.deleteSections(IndexSet(sectionsToRemove), with: .none)
                    }
                }
            } else {
                // we are scrolling in the last or second to last section
                // grab the last section and, if there is more than one page in the last section
                // (we never want to remove the only page in the last section unless there is another section between it and the user),
                // remove the last page and decrement reference counts
                let pageSize = 20 // todo: this should come from somewhere in Pachyderm
                let lastSection = timelineSegments.last!
                if lastSection.count > 2 * pageSize,
                    indexPath.row < lastSection.count - (2 * pageSize) {
                    // todo: this is in the hot path for scrolling, possibly move this to a background thread?
                    let statusesToRemove = lastSection[lastSection.count - pageSize..<lastSection.count]
                    for (id, _) in statusesToRemove {
                        mastodonController.persistentContainer.status(for: id)?.decrementReferenceCount()
                    }
                    timelineSegments[timelineSegments.count - 1].removeLast(pageSize)
                    
                    let removedIndexPaths = (lastSection.count - 20..<lastSection.count).map { IndexPath(row: $0, section: timelineSegments.count - 1) }
                    // Removing this DispatchQueue.main.async call causes things to break when scrolling
                    // back down towards the removed rows. There would be a index out of bounds crash
                    // because, while we've already removed the statuses from our model, the table view doesn't seem to know that.
                    // It seems like tableView update calls made from inside tableView(_:willDisplay:forRowAt:) are silently ignored.
                    // Calling tableView.numberOfRows(inSection: 0) when trapped in the debugger after the aforementioned IOOB
                    // will produce an incorrect value (it will be some multiple of pageSize too high).
                    // Deferring the tableView update until the next runloop iteration seems to solve that.
                    DispatchQueue.main.async {
                        UIView.performWithoutAnimation {
                            tableView.deleteRows(at: removedIndexPaths, with: .none)
                        }
                    }
                }
            }
        }
        
        // load older statuses, if necessary
        if indexPath.section == timelineSegments.count - 1,
            indexPath.row == timelineSegments[indexPath.section].count - 1 {
            guard let older = older else { return }
            
            let request = Client.getStatuses(timeline: timeline, range: older)
            mastodonController.run(request) { response in
                guard case let .success(newStatuses, pagination) = response else { fatalError() }
                self.older = pagination?.older
                self.mastodonController.persistentContainer.addAll(statuses: newStatuses) {
                    DispatchQueue.main.async {
                        let newRows = self.timelineSegments.last!.count..<(self.timelineSegments.last!.count + newStatuses.count)
                        let newIndexPaths = newRows.map { IndexPath(row: $0, section: self.timelineSegments.count - 1) }
                        self.timelineSegments[self.timelineSegments.count - 1].append(contentsOf: newStatuses.map { ($0.id, .unknown) })
                        
                        UIView.performWithoutAnimation {
                            self.tableView.insertRows(at: newIndexPaths, with: .none)
                        }
                    }
                }
            }
        }
    }

    override func tableView(_ tableView: UITableView, canEditRowAt indexPath: IndexPath) -> Bool {
        return true
    }
    
    override func tableView(_ tableView: UITableView, leadingSwipeActionsConfigurationForRowAt indexPath: IndexPath) -> UISwipeActionsConfiguration? {
        return (tableView.cellForRow(at: indexPath) as? TableViewSwipeActionProvider)?.leadingSwipeActionsConfiguration()
    }
    
    override func tableView(_ tableView: UITableView, trailingSwipeActionsConfigurationForRowAt indexPath: IndexPath) -> UISwipeActionsConfiguration? {
        return (tableView.cellForRow(at: indexPath) as? TableViewSwipeActionProvider)?.trailingSwipeActionsConfiguration()
    }
    
    // MARK: Interaction
    
    @objc func refreshStatuses(_ sender: Any) {
        guard let newer = newer else { return }
        
        let request = Client.getStatuses(timeline: timeline, range: newer)
        mastodonController.run(request) { response in
            guard case let .success(newStatuses, pagination) = response else { fatalError() }
            
            // If there is no new newer pagination, don't reset it, so that the user can continue refreshing for more recent statuses
            // Otherwise, when no new statuses were loaded, it would get reset and the the user would be unable to refresh
            if let newer = pagination?.newer {
                self.newer = newer
            }
            
            self.mastodonController.persistentContainer.addAll(statuses: newStatuses) {
                DispatchQueue.main.async {
                    self.timelineSegments[0].insert(contentsOf: newStatuses.map { ($0.id, .unknown) }, at: 0)
                    let newIndexPaths = (0..<newStatuses.count).map {
                        IndexPath(row: $0, section: 0)
                    }
                    UIView.performWithoutAnimation {
                        self.tableView.insertRows(at: newIndexPaths, with: .automatic)
                    }
                    
                    self.refreshControl?.endRefreshing()
                    
                    // maintain the current position in the list (don't scroll to the top)
                    self.tableView.scrollToRow(at: IndexPath(row: newStatuses.count, section: 0), at: .top, animated: false)
                }
            }
        }
    }

    @objc func composePressed(_ sender: Any) {
        compose()
    }
    
}

extension TimelineTableViewController: StatusTableViewCellDelegate {
    var apiController: MastodonController { mastodonController }
    
    func statusCellCollapsedStateChanged(_ cell: BaseStatusTableViewCell) {
        // causes the table view to recalculate the cell heights
        tableView.beginUpdates()
        tableView.endUpdates()
    }
}

extension TimelineTableViewController: UITableViewDataSourcePrefetching {
    func tableView(_ tableView: UITableView, prefetchRowsAt indexPaths: [IndexPath]) {
        for indexPath in indexPaths {
            guard let status = mastodonController.persistentContainer.status(for: statusID(for: indexPath)) else { continue }
            _ = ImageCache.avatars.get(status.account.avatar, completion: nil)
            for attachment in status.attachments where attachment.kind == .image {
                _ = ImageCache.attachments.get(attachment.url, completion: nil)
            }
        }
    }
    
    func tableView(_ tableView: UITableView, cancelPrefetchingForRowsAt indexPaths: [IndexPath]) {
        for indexPath in indexPaths {
            // todo: this means when removing cells, we can't cancel prefetching
            // is this an issue?
            guard indexPath.section < timelineSegments.count, indexPath.row < timelineSegments[indexPath.section].count,
                let status = mastodonController.persistentContainer.status(for: statusID(for: indexPath)) else { continue }
            ImageCache.avatars.cancelWithoutCallback(status.account.avatar)
            for attachment in status.attachments where attachment.kind == .image {
                ImageCache.attachments.cancelWithoutCallback(attachment.url)
            }
        }
    }
}