//
//  SceneDelegate.swift
//  Reader
//
//  Created by Shadowfacts on 10/29/21.
//

import Foundation
import UIKit
import OSLog
import Persistence

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    private(set) var fervorController: FervorController!
    private(set) var toggleReadBarButtonItem: UIBarButtonItem?
    
    private let logger = Logger(subsystem: Bundle.main.bundleIdentifier!, category: "SceneDelegate")

    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
        // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
        // This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).
        guard let windowScene = (scene as? UIWindowScene) else { return }
        
        window = UIWindow(windowScene: windowScene)
        window!.tintColor = .appTintColor
        
        var activity = connectionOptions.userActivities.first ?? session.stateRestorationActivity
        
        var account = LocalData.mostRecentAccount()
        
        if activity?.activityType == NSUserActivity.addAccountType {
            account = nil
        } else if let id = activity?.accountID() {
            account = LocalData.account(with: id)
            if account == nil {
                activity = nil
                logger.log("Missing account for activity, not restoring")
            }
        }
        
        if let account = account {
            Task { @MainActor [activity] in
                fervorController = await FervorController(account: account)
                syncFromServer()
                createAppUI()
                if !connectionOptions.urlContexts.isEmpty {
                    self.scene(scene, openURLContexts: connectionOptions.urlContexts)
                } else if let activity = activity {
                    await setupUI(from: activity)
                }
                setupSceneActivationConditions()
            }
        } else {
            createLoginUI()
        }
        
        #if targetEnvironment(macCatalyst)
        if let titlebar = windowScene.titlebar {
            titlebar.toolbarStyle = .unifiedCompact
            titlebar.toolbar = NSToolbar(identifier: .init("ReaderToolbar"))
            titlebar.toolbar!.delegate = self
            titlebar.toolbar!.allowsUserCustomization = false
        }
        #endif
        
        window!.makeKeyAndVisible()
        
        NotificationCenter.default.addObserver(self, selector: #selector(updateAppearance), name: .appearanceChanged, object: nil)
        updateAppearance()
    }

    func sceneDidDisconnect(_ scene: UIScene) {
        // Called as the scene is being released by the system.
        // This occurs shortly after the scene enters the background, or when its session is discarded.
        // Release any resources associated with this scene that can be re-created the next time the scene connects.
        // The scene may re-connect later, as its session was not necessarily discarded (see `application:didDiscardSceneSessions` instead).
    }

    func sceneDidBecomeActive(_ scene: UIScene) {
        // Called when the scene has moved from an inactive state to an active state.
        // Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive.
        
        UIMenuSystem.main.setNeedsRebuild()
        
        syncFromServer()
    }

    func sceneWillResignActive(_ scene: UIScene) {
        // Called when the scene will move from an active state to an inactive state.
        // This may occur due to temporary interruptions (ex. an incoming phone call).
    }

    func sceneWillEnterForeground(_ scene: UIScene) {
        // Called as the scene transitions from the background to the foreground.
        // Use this method to undo the changes made on entering the background.
    }

    func sceneDidEnterBackground(_ scene: UIScene) {
        // Called as the scene transitions from the foreground to the background.
        // Use this method to save data, release shared resources, and store enough scene-specific state information
        // to restore the scene back to its current state.
        
        if let fervorController = fervorController {
            Task(priority: .userInitiated) {
                await fervorController.syncReadToServer()
            }
            Task(priority: .userInitiated) {
                await WidgetHelper.updateWidgetData(fervorController: fervorController)
            }
        }
        
        BackgroundManager.shared.scheduleRefresh()
    }
    
    func stateRestorationActivity(for scene: UIScene) -> NSUserActivity? {
        return (window!.rootViewController as! AppSplitViewController).stateRestorationActivity()
    }
    
    func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
        Task { @MainActor in
            await setupUI(from: userActivity)
        }
    }
    
    func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
        let url = URLContexts.first!.url
        guard url.scheme == "reader",
              url.host == "item",
              let itemID = url.pathComponents.last else {
            logger.error("Launched with unknown URL: \(url.absoluteString, privacy: .public)")
            return
        }
        guard let split = window?.rootViewController as? AppSplitViewController else {
            logger.error("Could not handle URL: missing split VC")
            return
        }
        let req = Item.fetchRequest()
        req.predicate = NSPredicate(format: "id = %@", itemID)
        if let items = try? fervorController.persistentContainer.viewContext.fetch(req),
           let item = items.first {
            split.showItem(item)
            Task {
                await fervorController.markItem(item, read: true)
            }
        } else {
            Task {
                if let item = try? await fervorController.fetchItem(id: itemID) {
                    split.showItem(item)
                    await fervorController.markItem(item, read: true)
                }
            }
        }
    }
    
    private func setupUI(from activity: NSUserActivity) async {
        guard let split = window?.rootViewController as? AppSplitViewController else {
            logger.error("Failed to setup UI for user activity: missing split VC")
            return
        }
        switch activity.activityType {
        case NSUserActivity.readUnreadType:
            split.showItemList(.unread)
        case NSUserActivity.readAllType:
            split.showItemList(.all)
        case NSUserActivity.readFeedType:
            guard let feedID = activity.feedID else {
                break
            }
            let req = Feed.fetchRequest()
            req.predicate = NSPredicate(format: "id = %@", feedID)
            if let feed = try? fervorController.persistentContainer.viewContext.fetch(req).first {
                split.showItemList(.feed(feed))
            }
        case NSUserActivity.readGroupType:
            guard let groupID = activity.groupID else {
                break
            }
            let req = Group.fetchRequest()
            req.predicate = NSPredicate(format: "id = %@", groupID)
            if let group = try? fervorController.persistentContainer.viewContext.fetch(req).first {
                split.showItemList(.group(group))
            }
        case NSUserActivity.readItemType:
            guard let itemID = activity.itemID else {
                break
            }
            let req = Item.fetchRequest()
            req.predicate = NSPredicate(format: "id = %@", itemID)
            var read: ReadViewController? = nil
            if let item = try? fervorController.persistentContainer.viewContext.fetch(req).first {
                read = split.showItem(item)
            } else {
                if let item = try? await fervorController.fetchItem(id: itemID) {
                    read = split.showItem(item)
                }
            }
            read?.restoreUserActivityState(activity)
        default:
            logger.warning("Unknown user activity type: \(activity.activityType)")
            break
        }
    }
    
    private func createLoginUI() {
        let vc = LoginViewController()
        vc.delegate = self
        window!.rootViewController = vc
    }
    
    private func createAppUI() {
        window!.rootViewController = AppSplitViewController(fervorController: fervorController)
    }
    
    private func setupSceneActivationConditions() {
        guard let account = fervorController?.account else {
            return
        }
        let scene = self.window!.windowScene!
        // todo: why the fuck doesn't this work
        // it always picks the most recently focused window
        scene.activationConditions.prefersToActivateForTargetContentIdentifierPredicate = NSPredicate(format: "self == '\(account.id.base64EncodedString())'")
        scene.activationConditions.canActivateForTargetContentIdentifierPredicate = NSPredicate(value: true)
    }
    
    private func syncFromServer() {
        guard let fervorController = fervorController else {
            return
        }
        Task(priority: .userInitiated) {
            do {
                try await fervorController.syncAll()
            } catch {
                logger.error("Unable to sync from server: \(String(describing: error), privacy: .public)")
            }
        }
    }
    
    @objc private func updateAppearance() {
        switch Preferences.shared.appearance {
        case .unspecified:
            window!.overrideUserInterfaceStyle = .unspecified
        case .light:
            window!.overrideUserInterfaceStyle = .light
        case .dark:
            window!.overrideUserInterfaceStyle = .dark
        }
    }
    
    func switchToAccount(_ account: LocalData.Account) async {
        LocalData.mostRecentAccountID = account.id
        fervorController = await FervorController(account: account)
        createAppUI()
        syncFromServer()
    }

}

extension SceneDelegate: LoginViewControllerDelegate {
    func didLogin(with controller: FervorController) {
        Task { @MainActor in
            let account = LocalData.Account(instanceURL: controller.instanceURL, clientID: await controller.clientID!, clientSecret: await controller.clientSecret!, token: await controller.token!)
            LocalData.accounts.append(account)
            LocalData.mostRecentAccountID = account.id
            fervorController = await FervorController(account: account)
            
            createAppUI()
            syncFromServer()
            setupSceneActivationConditions()
            
            UIMenuSystem.main.setNeedsRebuild()
        }
    }
}

#if targetEnvironment(macCatalyst)
extension NSToolbarItem.Identifier {
    static let toggleItemRead = NSToolbarItem.Identifier("ToggleItemRead")
    static let shareItem = NSToolbarItem.Identifier("ShareItem")
}

extension SceneDelegate: NSToolbarDelegate {
    func toolbar(_ toolbar: NSToolbar, itemForItemIdentifier itemIdentifier: NSToolbarItem.Identifier, willBeInsertedIntoToolbar flag: Bool) -> NSToolbarItem? {
        if itemIdentifier == .toggleItemRead {
            // need an item bar button item to make the size of the image match the share button
            let item = NSToolbarItem(itemIdentifier: .toggleItemRead, barButtonItem: UIBarButtonItem(image: nil, style: .plain, target: nil, action: nil))
            item.image = UIImage(systemName: "checkmark.circle")
            item.target = nil
            item.action = #selector(ReadViewController.toggleItemRead(_:))
            return item
        } else if itemIdentifier == .shareItem {
            return NSSharingServicePickerToolbarItem(itemIdentifier: .shareItem)
        } else {
            return nil
        }
    }
    
    func toolbarAllowedItemIdentifiers(_ toolbar: NSToolbar) -> [NSToolbarItem.Identifier] {
        return [.shareItem, .toggleItemRead]
    }
    
    func toolbarDefaultItemIdentifiers(_ toolbar: NSToolbar) -> [NSToolbarItem.Identifier] {
        return [.shareItem, .toggleItemRead]
    }
}
#endif