Tusker/Tusker/Screens/Onboarding/OnboardingViewController.swift

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

import UIKit
import AuthenticationServices
import Pachyderm

protocol OnboardingViewControllerDelegate {
    @MainActor
    func didFinishOnboarding(account: LocalData.UserAccountInfo)
}

class OnboardingViewController: UINavigationController {

    var onboardingDelegate: OnboardingViewControllerDelegate?
    
    var instanceSelector = InstanceSelectorTableViewController()
    
    var authenticationSession: ASWebAuthenticationSession?
    
    init() {
        super.init(rootViewController: instanceSelector)
    }
    
    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        instanceSelector.delegate = self
    }
    
    @MainActor
    private func tryLoginTo(instanceURL: URL) async throws {
        let mastodonController = MastodonController(instanceURL: instanceURL)
        let clientID: String
        let clientSecret: String
        do {
            (clientID, clientSecret) = try await mastodonController.registerApp()
        } catch {
            throw Error.registeringApp(error)
        }
        let authCode = try await getAuthorizationCode(instanceURL: instanceURL, clientID: clientID)
        let accessToken: String
        do {
            accessToken = try await mastodonController.authorize(authorizationCode: authCode)
        } catch {
            throw Error.gettingAccessToken(error)
        }
        
        // construct a temporary UserAccountInfo instance for the MastodonController to use to fetch its own account
        let tempAccountInfo = LocalData.UserAccountInfo(tempInstanceURL: instanceURL, clientID: clientID, clientSecret: clientSecret, accessToken: accessToken)
        mastodonController.accountInfo = tempAccountInfo
        
        let ownAccount: Account
        do {
            ownAccount = try await mastodonController.getOwnAccount()
        } catch {
            throw Error.gettingOwnAccount(error)
        }
        
        let accountInfo = LocalData.shared.addAccount(instanceURL: instanceURL, clientID: clientID, clientSecret: clientSecret, username: ownAccount.username, accessToken: accessToken)
        mastodonController.accountInfo = accountInfo
        
        self.onboardingDelegate?.didFinishOnboarding(account: accountInfo)
    }
    
    @MainActor
    private func getAuthorizationCode(instanceURL: URL, clientID: String) async throws -> String {
        var components = URLComponents(url: instanceURL, resolvingAgainstBaseURL: false)!
        components.path = "/oauth/authorize"
        components.queryItems = [
            URLQueryItem(name: "client_id", value: clientID),
            URLQueryItem(name: "response_type", value: "code"),
            URLQueryItem(name: "scope", value: "read write follow"),
            URLQueryItem(name: "redirect_uri", value: "tusker://oauth")
        ]
        let authorizeURL = components.url!
        
        return try await withCheckedThrowingContinuation({ continuation in
            self.authenticationSession = ASWebAuthenticationSession(url: authorizeURL, callbackURLScheme: "tusker", completionHandler: { url, error in
                if let error = error {
                    if (error as? ASWebAuthenticationSessionError)?.code == .canceledLogin {
                        continuation.resume(throwing: Error.cancelled)
                    } else {
                        continuation.resume(throwing: Error.authenticationSessionError(error))
                    }
                } else if let url = url,
                          let components = URLComponents(url: url, resolvingAgainstBaseURL: true),
                          let item = components.queryItems?.first(where: { $0.name == "code" }),
                          let code = item.value {
                    continuation.resume(returning: code)
                } else {
                    continuation.resume(throwing: Error.noAuthorizationCode)
                }
            })
            // Prefer ephemeral sessions to make it easier to sign into multiple accounts on the same instance.
            self.authenticationSession!.prefersEphemeralWebBrowserSession = true
            self.authenticationSession!.presentationContextProvider = self
            self.authenticationSession!.start()
        })
    }

}

extension OnboardingViewController {
    enum Error: Swift.Error {
        case cancelled
        case registeringApp(Swift.Error)
        case authenticationSessionError(Swift.Error)
        case noAuthorizationCode
        case gettingAccessToken(Swift.Error)
        case gettingOwnAccount(Swift.Error)
        
        var localizedDescription: String {
            switch self {
            case .cancelled:
                return "Login Cancelled"
            case .registeringApp(let error):
                return "Couldn't register app: \(error)"
            case .authenticationSessionError(let error):
                return error.localizedDescription
            case .noAuthorizationCode:
                return "No authorization code"
            case .gettingAccessToken(let error):
                return "Couldn't get access token: \(error)"
            case .gettingOwnAccount(let error):
                return "Couldn't fetch account: \(error)"
            }
        }
    }
}

extension OnboardingViewController: InstanceSelectorTableViewControllerDelegate {
    func didSelectInstance(url instanceURL: URL) {
        Task {
            do {
                try await self.tryLoginTo(instanceURL: instanceURL)
            } catch Error.cancelled {
                // no-op, don't show an error message
            } catch let error as Error {
                let alert = UIAlertController(title: "Error Logging In", message: error.localizedDescription, preferredStyle: .alert)
                alert.addAction(UIAlertAction(title: "OK", style: .default))
                self.present(alert, animated: true)
            }
        }
    }
}

extension OnboardingViewController: ASWebAuthenticationPresentationContextProviding {
    func presentationAnchor(for session: ASWebAuthenticationSession) -> ASPresentationAnchor {
        return view.window!
    }
}