//
//  MainSidebarViewController.swift
//  Tusker
//
//  Created by Shadowfacts on 6/24/20.
//  Copyright © 2020 Shadowfacts. All rights reserved.
//

import UIKit
import Pachyderm

protocol MainSidebarViewControllerDelegate: AnyObject {
    func sidebarRequestPresentCompose(_ sidebarViewController: MainSidebarViewController)
    func sidebar(_ sidebarViewController: MainSidebarViewController, didSelectItem item: MainSidebarViewController.Item)
}

class MainSidebarViewController: UIViewController {
    
    private weak var mastodonController: MastodonController!
    
    weak var sidebarDelegate: MainSidebarViewControllerDelegate?
    
    private var collectionView: UICollectionView!
    private var dataSource: UICollectionViewDiffableDataSource<Section, Item>!
    
    var allItems: [Item] {
        [
            .tab(.timelines),
            .tab(.notifications),
            .tab(.myProfile),
        ] + exploreTabItems
    }
    
    var exploreTabItems: [Item] {
        var items: [Item] = [.search, .bookmarks, .trendingTags, .profileDirectory]
        let snapshot = dataSource.snapshot()
        for case let .list(list) in snapshot.itemIdentifiers(inSection: .lists) {
            items.append(.list(list))
        }
        for case let .savedHashtag(hashtag) in snapshot.itemIdentifiers(inSection: .savedHashtags) {
            items.append(.savedHashtag(hashtag))
        }
        for case let .savedInstance(instance) in snapshot.itemIdentifiers(inSection: .savedInstances) {
            items.append(.savedInstance(instance))
        }
        return items
    }
    
    private(set) var previouslySelectedItem: Item?
    var selectedItem: Item? {
        guard let indexPath = collectionView?.indexPathsForSelectedItems?.first else {
            return nil
        }
        return dataSource.itemIdentifier(for: indexPath)
    }
    
    private(set) var itemLastSelectedTimestamps = [Item: Date]()

    init(mastodonController: MastodonController) {
        self.mastodonController = mastodonController
        
        super.init(nibName: nil, bundle: nil)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()

        navigationItem.title = "Tusker"
        navigationItem.largeTitleDisplayMode = .always
        navigationController!.navigationBar.prefersLargeTitles = true
        
        let layout = UICollectionViewCompositionalLayout.list(using: .init(appearance: .sidebar))
        collectionView = UICollectionView(frame: view.bounds, collectionViewLayout: layout)
        collectionView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        collectionView.backgroundColor = .clear
        collectionView.delegate = self
        collectionView.dragDelegate = self
        collectionView.isSpringLoaded = true
        view.addSubview(collectionView)
        
        dataSource = createDataSource()
        
        applyInitialSnapshot()
        
        if mastodonController.instance == nil {
            mastodonController.getOwnInstance(completion: self.ownInstanceLoaded(_:))
        }
        
        select(item: .tab(.timelines), animated: false)
        
        NotificationCenter.default.addObserver(self, selector: #selector(reloadSavedHashtags), name: .savedHashtagsChanged, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(reloadSavedInstances), name: .savedInstancesChanged, object: nil)
    }
    
    func select(item: Item, animated: Bool) {
        // ensure view is loaded, since dataSource is created in viewDidLoad
        loadViewIfNeeded()
        guard let indexPath = dataSource.indexPath(for: item) else { return }
        collectionView.selectItem(at: indexPath, animated: animated, scrollPosition: .top)
        itemLastSelectedTimestamps[item] = Date()
    }
    
    private func createDataSource() -> UICollectionViewDiffableDataSource<Section, Item> {
        let listCell = UICollectionView.CellRegistration<UICollectionViewListCell, Item> { (cell, indexPath, item) in
            var config = cell.defaultContentConfiguration()
            config.text = item.title
            if let imageName = item.imageName {
                config.image = UIImage(systemName: imageName)
            }
            cell.contentConfiguration = config
        }
        
        let outlineHeaderCell = UICollectionView.CellRegistration<UICollectionViewListCell, Item> { (cell, indexPath, item) in
            var config = cell.defaultContentConfiguration()
            config.attributedText = NSAttributedString(string: item.title, attributes: [
                .font: UIFont.boldSystemFont(ofSize: 21)
            ])
            cell.contentConfiguration = config
            cell.accessories = [.outlineDisclosure(options: .init(style: .header))]
        }
        
        return UICollectionViewDiffableDataSource<Section, Item>(collectionView: collectionView, cellProvider: { (collectionView, indexPath, item) -> UICollectionViewCell? in
            if item.hasChildren {
                return collectionView.dequeueConfiguredReusableCell(using: outlineHeaderCell, for: indexPath, item: item)
            } else {
                return collectionView.dequeueConfiguredReusableCell(using: listCell, for: indexPath, item: item)
            }
        })
    }

    private func applyInitialSnapshot() {
        var snapshot = NSDiffableDataSourceSnapshot<Section, Item>()
        snapshot.appendSections(Section.allCases.filter { $0 != .discover })
        snapshot.appendItems([
            .tab(.timelines),
            .tab(.notifications),
            .search,
            .bookmarks,
            .tab(.myProfile)
        ], toSection: .tabs)
        snapshot.appendItems([
            .tab(.compose)
        ], toSection: .compose)
        if case .mastodon = mastodonController.instance?.instanceType {
            snapshot.insertSections([.discover], afterSection: .compose)
            snapshot.appendItems([
                .trendingTags,
                .profileDirectory,
            ], toSection: .discover)
        }
        dataSource.apply(snapshot, animatingDifferences: false)
        
        reloadLists()
        reloadSavedHashtags()
        reloadSavedInstances()
    }
    
    private func ownInstanceLoaded(_ instance: Instance) {
        var snapshot = self.dataSource.snapshot()
        if case .mastodon = mastodonController.instance?.instanceType {
            snapshot.insertSections([.discover], afterSection: .compose)
            snapshot.appendItems([
                .trendingTags,
                .profileDirectory,
            ], toSection: .discover)
        }
        let prevSelected = collectionView.indexPathsForSelectedItems
        
        dataSource.apply(snapshot, animatingDifferences: false)
        
        if let prevSelected = prevSelected?.first {
            collectionView.selectItem(at: prevSelected, animated: false, scrollPosition: .top)
        }
    }
    
    private func reloadLists() {
        let request = Client.getLists()
        mastodonController.run(request) { [weak self] (response) in
            guard let self = self, case let .success(lists, _) = response else { return }
            
            var exploreSnapshot = NSDiffableDataSourceSectionSnapshot<Item>()
            exploreSnapshot.append([.listsHeader])
            exploreSnapshot.expand([.listsHeader])
            exploreSnapshot.append(lists.map { .list($0) }, to: .listsHeader)
            exploreSnapshot.append([.addList], to: .listsHeader)
            DispatchQueue.main.async {
                let selected = self.collectionView.indexPathsForSelectedItems?.first

                self.dataSource.apply(exploreSnapshot, to: .lists) {
                    if let selected = selected {
                        self.collectionView.selectItem(at: selected, animated: false, scrollPosition: .centeredVertically)
                    }
                }
            }
        }
    }
    
    @objc private func reloadSavedHashtags() {
        let selected = collectionView.indexPathsForSelectedItems?.first

        var hashtagsSnapshot = NSDiffableDataSourceSectionSnapshot<Item>()
        hashtagsSnapshot.append([.savedHashtagsHeader])
        hashtagsSnapshot.expand([.savedHashtagsHeader])
        let sortedHashtags = SavedDataManager.shared.sortedHashtags(for: mastodonController.accountInfo!)
        hashtagsSnapshot.append(sortedHashtags.map { .savedHashtag($0) }, to: .savedHashtagsHeader)
        hashtagsSnapshot.append([.addSavedHashtag], to: .savedHashtagsHeader)
        self.dataSource.apply(hashtagsSnapshot, to: .savedHashtags, animatingDifferences: false) {
            if let selected = selected {
                self.collectionView.selectItem(at: selected, animated: false, scrollPosition: .centeredVertically)
            }
        }
    }
    
    @objc private func reloadSavedInstances() {
        let selected = collectionView.indexPathsForSelectedItems?.first
        
        var instancesSnapshot = NSDiffableDataSourceSectionSnapshot<Item>()
        instancesSnapshot.append([.savedInstancesHeader])
        instancesSnapshot.expand([.savedInstancesHeader])
        let sortedInstances = SavedDataManager.shared.savedInstances(for: mastodonController.accountInfo!)
        instancesSnapshot.append(sortedInstances.map { .savedInstance($0) }, to: .savedInstancesHeader)
        instancesSnapshot.append([.addSavedInstance], to: .savedInstancesHeader)
        self.dataSource.apply(instancesSnapshot, to: .savedInstances, animatingDifferences: false) {
            if let selected = selected {
                self.collectionView.selectItem(at: selected, animated: false, scrollPosition: .centeredVertically)
            }
        }
    }

    // todo: deduplicate with ExploreViewController
    private func showAddList() {
        let alert = UIAlertController(title: "New List", message: "Choose a title for your new list", preferredStyle: .alert)
        alert.addTextField(configurationHandler: nil)
        alert.addAction(UIAlertAction(title: "Cancel", style: .cancel, handler: nil))
        alert.addAction(UIAlertAction(title: "Create List", style: .default, handler: { (_) in
            guard let title = alert.textFields?.first?.text else {
                fatalError()
            }
            
            let request = Client.createList(title: title)
            self.mastodonController.run(request) { (response) in
                guard case let .success(list, _) = response else { fatalError() }
                
                self.reloadLists()
                
                DispatchQueue.main.async {
                    self.sidebarDelegate?.sidebar(self, didSelectItem: .list(list))
                }
            }
        }))
        present(alert, animated: true)
    }
    
    // todo: deduplicate with ExploreViewController
    private func showAddSavedHashtag() {
        let navController = EnhancedNavigationViewController(rootViewController: AddSavedHashtagViewController(mastodonController: mastodonController))
        present(navController, animated: true)
    }
    
    // todo: deduplicate with ExploreViewController
    private func showAddSavedInstance() {
        let findController = FindInstanceViewController(parentMastodonController: mastodonController)
        findController.instanceTimelineDelegate = self
        let navController = EnhancedNavigationViewController(rootViewController: findController)
        present(navController, animated: true)
    }
    
    private func userActivityForItem(_ item: Item) -> NSUserActivity? {
        guard let id = mastodonController.accountInfo?.id else { return nil }
        
        switch item {
        case .tab(.notifications):
            return UserActivityManager.checkNotificationsActivity(mode: Preferences.shared.defaultNotificationsMode)
        case .tab(.compose):
            return UserActivityManager.newPostActivity(accountID: id)
        case .search:
            return UserActivityManager.searchActivity()
        case .bookmarks:
            return UserActivityManager.bookmarksActivity()
        case .tab(.myProfile):
            return UserActivityManager.myProfileActivity()
        case let .list(list):
            return UserActivityManager.showTimelineActivity(timeline: .list(id: list.id), accountID: id)
        case let .savedHashtag(tag):
            return UserActivityManager.showTimelineActivity(timeline: .tag(hashtag: tag.name), accountID: id)
        case .savedInstance(_):
            // todo: show timeline activity doesn't work for public timelines
            return nil
        default:
            return nil
        }
    }
    
}

extension MainSidebarViewController {
    enum Section: Int, Hashable, CaseIterable {
        case tabs
        case compose
        case discover
        case lists
        case savedHashtags
        case savedInstances
    }
    enum Item: Hashable {
        case tab(MainTabBarViewController.Tab)
        case search, bookmarks
        case trendingTags, profileDirectory
        case listsHeader, list(List), addList
        case savedHashtagsHeader, savedHashtag(Hashtag), addSavedHashtag
        case savedInstancesHeader, savedInstance(URL), addSavedInstance
        
        var title: String {
            switch self {
            case let .tab(tab):
                return tab.title
            case .search:
                return "Search"
            case .bookmarks:
                return "Bookmarks"
            case .trendingTags:
                return "Trending Hashtags"
            case .profileDirectory:
                return "Profile Directory"
            case .listsHeader:
                return "Lists"
            case let .list(list):
                return list.title
            case .addList:
                return "New List..."
            case .savedHashtagsHeader:
                return "Saved Hashtags"
            case let .savedHashtag(hashtag):
                return hashtag.name
            case .addSavedHashtag:
                return "Save Hashtag..."
            case .savedInstancesHeader:
                return "Saved Instances"
            case let .savedInstance(url):
                return url.host!
            case .addSavedInstance:
                return "Find An Instance..."
            }
        }
        
        var imageName: String? {
            switch self {
            case let .tab(tab):
                return tab.imageName
            case .search:
                return "magnifyingglass"
            case .bookmarks:
                return "bookmark"
            case .trendingTags:
                return "arrow.up.arrow.down"
            case .profileDirectory:
                return "person.2.fill"
            case .list(_):
                return "list.bullet"
            case .savedHashtag(_):
                return "number"
            case .savedInstance(_):
                return "globe"
            case .listsHeader, .savedHashtagsHeader, .savedInstancesHeader:
                return nil
            case .addList, .addSavedHashtag, .addSavedInstance:
                return "plus"
            }
        }
        
        var hasChildren: Bool {
            switch self {
            case .listsHeader, .savedHashtagsHeader, .savedInstancesHeader:
                return true
            default:
                return false
            }
        }
    }
}

fileprivate extension MainTabBarViewController.Tab {
    var title: String {
        switch self {
        case .timelines:
            return "Home"
        case .notifications:
            return "Notifications"
        case .compose:
            return "Compose"
        case .explore:
            return "Explore"
        case .myProfile:
            return "My Profile"
        }
    }
    
    var imageName: String? {
        switch self {
        case .timelines:
            return "house"
        case .notifications:
            return "bell"
        case .compose:
            return "pencil"
        case .explore:
            return "magnifyingglass"
        case .myProfile:
            // todo: use user avatar image
            return "person"
        }
    }
}

extension MainSidebarViewController: UICollectionViewDelegate {
    func collectionView(_ collectionView: UICollectionView, shouldSelectItemAt indexPath: IndexPath) -> Bool {
        previouslySelectedItem = selectedItem
        return true
    }
    
    func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
        guard let item = dataSource.itemIdentifier(for: indexPath) else {
            collectionView.deselectItem(at: indexPath, animated: true)
            return
        }
        itemLastSelectedTimestamps[item] = Date()
        if [MainSidebarViewController.Item.tab(.compose), .addList, .addSavedHashtag, .addSavedInstance].contains(item) {
            if let previous = previouslySelectedItem, let indexPath = dataSource.indexPath(for: previous) {
                collectionView.selectItem(at: indexPath, animated: false, scrollPosition: .centeredVertically)
            }
            switch item {
            case .tab(.compose):
                sidebarDelegate?.sidebarRequestPresentCompose(self)
            case .addList:
                showAddList()
            case .addSavedHashtag:
                showAddSavedHashtag()
            case .addSavedInstance:
                showAddSavedInstance()
            default:
                fatalError("unreachable")
            }
        } else {
            sidebarDelegate?.sidebar(self, didSelectItem: item)
        }
    }
}

extension MainSidebarViewController: UICollectionViewDragDelegate {
    func collectionView(_ collectionView: UICollectionView, itemsForBeginning session: UIDragSession, at indexPath: IndexPath) -> [UIDragItem] {
        guard let item = dataSource.itemIdentifier(for: indexPath),
              let activity = userActivityForItem(item) else {
            return []
        }
        
        let provider = NSItemProvider(object: activity)
        return [UIDragItem(itemProvider: provider)]
    }
}

extension MainSidebarViewController: InstanceTimelineViewControllerDelegate {
    func didSaveInstance(url: URL) {
        dismiss(animated: true) {
            self.sidebarDelegate?.sidebar(self, didSelectItem: .savedInstance(url))
        }
    }
    
    func didUnsaveInstance(url: URL) {
        dismiss(animated: true)
    }
}