Gemini/Gemini-iOS/SceneDelegate.swift

//
//  SceneDelegate.swift
//  Gemini-iOS
//
//  Created by Shadowfacts on 7/15/20.
//

import UIKit
import SwiftUI
import BrowserCore
import SafariServices
import Combine
import Intents

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    var navigationManager: NavigationManager!
    
    private var cancellables = [AnyCancellable]()

    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).
        
        navigationManager = createNavigationManager(for: session, with: connectionOptions)
        navigationManager.delegate = self
        
        // Create the SwiftUI view that provides the window contents.
//        let contentView = ContentView(navigator: navigationManager)

        // Use a UIHostingController as window root view controller.
        if let windowScene = scene as? UIWindowScene {
            let window = UIWindow(windowScene: windowScene)
            window.overrideUserInterfaceStyle = Preferences.shared.theme
            window.rootViewController = BrowserNavigationController(navigator: navigationManager)
//            window.rootViewController = UIHostingController(rootView: contentView)
//            window.rootViewController = BrowserViewController(navigator: navigationManager)
            self.window = window
            window.makeKeyAndVisible()
        }
        
        Preferences.shared.$theme
            .sink { [unowned self] (newStyle) in
                self.window!.overrideUserInterfaceStyle = newStyle
            }
            .store(in: &cancellables)
    }
    
    func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
        if let context = URLContexts.first {
            navigationManager.changeURL(context.url)
        }
    }
    
    func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
        if let url = userActivity.geminiURL {
            navigationManager.changeURL(url)
        }
    }

    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.
    }

    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.
    }
    
    func stateRestorationActivity(for scene: UIScene) -> NSUserActivity? {
        return NSUserActivity(navigationManager: navigationManager)
    }
    
    private func createNavigationManager(for session: UISceneSession, with connectionOptions: UIScene.ConnectionOptions) -> NavigationManager {
        // try to restore the existing nav manager if there is one
        if let manager = session.stateRestorationActivity?.navigationManager {
            // if there's a user activity with a gemini url (e.g., from OpenURLIntentHandler),
            // navigate the existing manager to that URL
            if let newURL = connectionOptions.userActivities.first?.geminiURL {
                manager.changeURL(newURL)
            }
            return manager
        }
        
        // otherwise, work out the initial URL and create a new manager
        
        var initialURL: URL? = nil
        
        if let activity = connectionOptions.userActivities.first ?? session.stateRestorationActivity {
            if let manager = activity.navigationManager {
                return manager
            } else if let url = activity.geminiURL {
                initialURL = url
            }
        }
        
        if initialURL == nil {
            initialURL = connectionOptions.urlContexts.first?.url
        }
        
        if initialURL == nil {
            if ProcessInfo.processInfo.environment.keys.contains("DEFAULT_URL") {
                initialURL = URL(string: ProcessInfo.processInfo.environment["DEFAULT_URL"]!)!
            } else {
                initialURL = Preferences.shared.homepage
            }
        }
        
        return NavigationManager(url: initialURL!)
    }

}

extension SceneDelegate: NavigationManagerDelegate {
    func loadNonGeminiURL(_ url: URL) {
        UIApplication.shared.open(url, options: [.universalLinksOnly: true]) { (success) in
            guard !success else { return }
            if url.scheme == "http" || url.scheme == "https" {
                if Preferences.shared.useInAppSafari {
                    let config = SFSafariViewController.Configuration()
                    config.entersReaderIfAvailable = Preferences.shared.useReaderMode
                    let vc = SFSafariViewController(url: url, configuration: config)
                    self.window?.rootViewController?.present(vc, animated: true)
                } else {
                    UIApplication.shared.open(url, options: [:])
                }
            } else {
                let alert = UIAlertController(title: "Cannot open '\(url.scheme!)' URL", message: url.absoluteString, preferredStyle: .alert)
                alert.addAction(UIAlertAction(title: "Copy URL", style: .default, handler: { (_) in
                    UIPasteboard.general.setObjects([url])
                }))
                alert.addAction(UIAlertAction(title: "OK", style: .cancel, handler: nil))
                self.window!.rootViewController!.present(alert, animated: true)
            }
        }
    }
}