//
//  NotificationsTableViewController.swift
//  Tusker
//
//  Created by Shadowfacts on 9/2/18.
//  Copyright © 2018 Shadowfacts. All rights reserved.
//

import UIKit
import Pachyderm

class NotificationsTableViewController: TimelineLikeTableViewController<NotificationGroup> {

    private let statusCell = "statusCell"
    private let actionGroupCell = "actionGroupCell"
    private let followGroupCell = "followGroupCell"
    private let followRequestCell = "followRequestCell"
    private let pollCell = "pollCell"
    private let unknownCell = "unknownCell"
    
    weak var mastodonController: MastodonController!
    
    private let excludedTypes: [Pachyderm.Notification.Kind]
    private let groupTypes = [Pachyderm.Notification.Kind.favourite, .reblog, .follow]
    
    private var newer: RequestRange?
    private var older: RequestRange?
    
    init(allowedTypes: [Pachyderm.Notification.Kind], mastodonController: MastodonController) {
        self.excludedTypes = Array(Set(Pachyderm.Notification.Kind.allCases).subtracting(allowedTypes))
        self.mastodonController = mastodonController
        
        super.init()
        
        dragEnabled = true
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override class func refreshCommandTitle() -> String {
        return NSLocalizedString("Refresh Notifications", comment: "refresh notifications command discoverability title")
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        tableView.register(UINib(nibName: "TimelineStatusTableViewCell", bundle: .main), forCellReuseIdentifier: statusCell)
        tableView.register(UINib(nibName: "ActionNotificationGroupTableViewCell", bundle: .main), forCellReuseIdentifier: actionGroupCell)
        tableView.register(UINib(nibName: "FollowNotificationGroupTableViewCell", bundle: .main), forCellReuseIdentifier: followGroupCell)
        tableView.register(UINib(nibName: "FollowRequestNotificationTableViewCell", bundle: .main), forCellReuseIdentifier: followRequestCell)
        tableView.register(UINib(nibName: "PollFinishedTableViewCell", bundle: .main), forCellReuseIdentifier: pollCell)
        tableView.register(UINib(nibName: "BasicTableViewCell", bundle: .main), forCellReuseIdentifier: unknownCell)
    }
    
    override func loadInitialItems(completion: @escaping ([NotificationGroup]) -> Void) {
        let request = Client.getNotifications(excludeTypes: excludedTypes)
        mastodonController.run(request) { (response) in
            guard case let .success(notifications, pagination) = response else {
                completion([])
                return
            }
            
            let groups = NotificationGroup.createGroups(notifications: notifications, only: self.groupTypes)
            
            self.newer = pagination?.newer
            self.older = pagination?.older
            
            self.mastodonController.persistentContainer.addAll(notifications: notifications) {
                completion(groups)
            }
        }
    }
    
    override func loadOlder(completion: @escaping ([NotificationGroup]) -> Void) {
        guard let older = older else {
            completion([])
            return
        }
        
        let request = Client.getNotifications(excludeTypes: excludedTypes, range: older)
        mastodonController.run(request) { (response) in
            guard case let .success(newNotifications, pagination) = response else { fatalError() }
            
            self.older = pagination?.older
            
            let groups = NotificationGroup.createGroups(notifications: newNotifications, only: self.groupTypes)
            
            self.mastodonController.persistentContainer.addAll(notifications: newNotifications) {
                completion(groups)
            }
        }
    }
    
    override func loadNewer(completion: @escaping ([NotificationGroup]) -> Void) {
        guard let newer = newer else {
            completion([])
            return
        }
        
        let request = Client.getNotifications(excludeTypes: excludedTypes, range: newer)
        mastodonController.run(request) { (response) in
            guard case let .success(newNotifications, pagination) = response else { fatalError() }
            
            if let newer = pagination?.newer {
                self.newer = newer
            }
            
            let groups = NotificationGroup.createGroups(notifications: newNotifications, only: self.groupTypes)
            
            self.mastodonController.persistentContainer.addAll(notifications: newNotifications) {
                completion(groups)
            }
        }
    }
    
    private func dismissNotificationsInGroup(at indexPath: IndexPath, completion: (() -> Void)? = nil) {
        let group = DispatchGroup()
        item(for: indexPath).notifications
            .map { Pachyderm.Notification.dismiss(id: $0.id) }
            .forEach { (request) in
                group.enter()
                mastodonController.run(request) { (_) in
                    group.leave()
                }
            }
        group.notify(queue: .main) {
            self.sections[indexPath.section].remove(at: indexPath.row)
            self.tableView.deleteRows(at: [indexPath], with: .automatic)
            completion?()
        }
    }
    
    // MARK: - UITableViewDataSource
    override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let group = item(for: indexPath)
        
        switch group.kind {
        case .mention:
            guard let notification = group.notifications.first,
                let cell = tableView.dequeueReusableCell(withIdentifier: statusCell, for: indexPath) as? TimelineStatusTableViewCell else {
                fatalError()
            }
            cell.delegate = self
            cell.updateUI(statusID: notification.status!.id, state: group.statusState!)
            return cell
            
        case .favourite, .reblog:
            guard let cell = tableView.dequeueReusableCell(withIdentifier: actionGroupCell, for: indexPath) as? ActionNotificationGroupTableViewCell else { fatalError() }
            cell.delegate = self
            cell.updateUI(group: group)
            return cell
            
        case .follow:
            guard let cell = tableView.dequeueReusableCell(withIdentifier: followGroupCell, for: indexPath) as? FollowNotificationGroupTableViewCell else { fatalError() }
            cell.delegate = self
            cell.updateUI(group: group)
            return cell
            
        case .followRequest:
            guard let notification = group.notifications.first,
                let cell = tableView.dequeueReusableCell(withIdentifier: followRequestCell, for: indexPath) as? FollowRequestNotificationTableViewCell else { fatalError() }
            cell.delegate = self
            cell.updateUI(notification: notification)
            return cell
            
        case .poll:
            guard let notification = group.notifications.first,
                  let cell = tableView.dequeueReusableCell(withIdentifier: pollCell, for: indexPath) as? PollFinishedTableViewCell else { fatalError() }
            cell.delegate = self
            cell.updateUI(notification: notification)
            return cell
            
        case .unknown:
            let cell = tableView.dequeueReusableCell(withIdentifier: unknownCell, for: indexPath)
            cell.textLabel!.text = NSLocalizedString("Unknown Notification", comment: "unknown notification fallback cell text")
            return cell
        }
    }
    
    // MARK: - UITableViewDelegate
    
    override func tableView(_ tableView: UITableView, trailingSwipeActionsConfigurationForRowAt indexPath: IndexPath) -> UISwipeActionsConfiguration? {
        let dismissAction = UIContextualAction(style: .destructive, title: NSLocalizedString("Dismiss", comment: "dismiss notification swipe action title")) { (action, view, completion) in
            self.dismissNotificationsInGroup(at: indexPath) {
                completion(true)
            }
        }
        dismissAction.image = UIImage(systemName: "clear.fill")
        
        let cellConfiguration = (tableView.cellForRow(at: indexPath) as? TableViewSwipeActionProvider)?.trailingSwipeActionsConfiguration()
        
        let config: UISwipeActionsConfiguration
        if let cellConfiguration = cellConfiguration {
            config = UISwipeActionsConfiguration(actions: cellConfiguration.actions + [dismissAction])
            config.performsFirstActionWithFullSwipe = cellConfiguration.performsFirstActionWithFullSwipe
        } else {
            config = UISwipeActionsConfiguration(actions: [dismissAction])
            config.performsFirstActionWithFullSwipe = false
        }
        return config
    }
    
    override func getSuggestedContextMenuActions(tableView: UITableView, indexPath: IndexPath, point: CGPoint) -> [UIAction] {
        return [
            UIAction(title: "Dismiss Notification", image: UIImage(systemName: "clear.fill"), identifier: .init("dismissnotification"), handler: { (_) in
                self.dismissNotificationsInGroup(at: indexPath)
            })
        ]
    }
}

extension NotificationsTableViewController: TuskerNavigationDelegate {
    var apiController: MastodonController { mastodonController }
}

extension NotificationsTableViewController: StatusTableViewCellDelegate {
    func statusCellCollapsedStateChanged(_ cell: BaseStatusTableViewCell) {
        cellHeightChanged()
    }
}

extension NotificationsTableViewController: UITableViewDataSourcePrefetching {
    func tableView(_ tableView: UITableView, prefetchRowsAt indexPaths: [IndexPath]) {
        for indexPath in indexPaths {
            for notification in item(for: indexPath).notifications {
                ImageCache.avatars.fetchIfNotCached(notification.account.avatar)
            }
        }
    }
    
    func tableView(_ tableView: UITableView, cancelPrefetchingForRowsAt indexPaths: [IndexPath]) {
        for indexPath in indexPaths {
            for notification in item(for: indexPath).notifications {
                ImageCache.avatars.cancelWithoutCallback(notification.account.avatar)
            }
        }
    }
}