Tusker/Tusker/Controllers/MastodonController.swift

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

import Foundation
import Pachyderm

class MastodonController: ObservableObject {

    static private(set) var all = [LocalData.UserAccountInfo: MastodonController]()
    
    @available(*, message: "do something less dumb")
    static var first: MastodonController { all.first!.value }
    
    static func getForAccount(_ account: LocalData.UserAccountInfo) -> MastodonController {
        if let controller = all[account] {
            return controller
        } else {
            let controller = MastodonController(instanceURL: account.instanceURL)
            controller.accountInfo = account
            controller.client.clientID = account.clientID
            controller.client.clientSecret = account.clientSecret
            controller.client.accessToken = account.accessToken
            all[account] = controller
            return controller
        }
    }
    
    static func resetAll() {
        all = [:]
    }
    
    private let transient: Bool
    private(set) lazy var persistentContainer = MastodonCachePersistentStore(for: accountInfo, transient: transient)

    let instanceURL: URL
    var accountInfo: LocalData.UserAccountInfo?
    
    let client: Client!
    
    @Published private(set) var account: Account!
    @Published private(set) var instance: Instance!
    private(set) var customEmojis: [Emoji]?
    
    var loggedIn: Bool {
        accountInfo != nil
    }

    init(instanceURL: URL, transient: Bool = false) {
        self.instanceURL = instanceURL
        self.accountInfo = nil
        self.client = Client(baseURL: instanceURL)
        self.transient = transient
    }
    
    @discardableResult
    func run<Result>(_ request: Request<Result>, completion: @escaping Client.Callback<Result>) -> URLSessionTask? {
        return client.run(request, completion: completion)
    }
    
    func registerApp(completion: @escaping (_ clientID: String, _ clientSecret: String) -> Void) {
        guard client.clientID == nil,
            client.clientSecret == nil else {
                
                completion(client.clientID!, client.clientSecret!)
                return
        }

        client.registerApp(name: "Tusker", redirectURI: "tusker://oauth", scopes: [.read, .write, .follow]) { response in
            guard case let .success(app, _) = response else { fatalError() }
            self.client.clientID = app.clientID
            self.client.clientSecret = app.clientSecret
            completion(app.clientID, app.clientSecret)
        }
    }
    
    func authorize(authorizationCode: String, completion: @escaping (_ accessToken: String) -> Void) {
        client.getAccessToken(authorizationCode: authorizationCode, redirectURI: "tusker://oauth") { response in
            guard case let .success(settings, _) = response else { fatalError() }
            self.client.accessToken = settings.accessToken
            completion(settings.accessToken)
        }
    }
    
    func getOwnAccount(completion: ((Result<Account, Client.Error>) -> Void)? = nil) {
        if account != nil {
            completion?(.success(account))
        } else {
            let request = Client.getSelfAccount()
            run(request) { response in
                switch response {
                case let .failure(error):
                    completion?(.failure(error))
                    
                case let .success(account, _):
                    DispatchQueue.main.async {
                        self.account = account
                    }
                    self.persistentContainer.backgroundContext.perform {
                        if let accountMO = self.persistentContainer.account(for: account.id, in: self.persistentContainer.backgroundContext) {
                            accountMO.updateFrom(apiAccount: account, container: self.persistentContainer)
                        } else {
                            // the first time the user's account is added to the store,
                            // increment its reference count so that it's never removed
                            self.persistentContainer.addOrUpdate(account: account, incrementReferenceCount: true)
                        }
                        completion?(.success(account))
                    }
                }
            }
        }
    }
    
    func getOwnInstance(completion: ((Instance) -> Void)? = nil) {
        if let instance = self.instance {
            completion?(instance)
        } else {
            let request = Client.getInstance()
            run(request) { (response) in
                guard case let .success(instance, _) = response else { fatalError() }
                DispatchQueue.main.async {
                    self.instance = instance
                    completion?(instance)
                }
            }
        }
    }
    
    func getCustomEmojis(completion: @escaping ([Emoji]) -> Void) {
        if let emojis = self.customEmojis {
            completion(emojis)
        } else {
            let request = Client.getCustomEmoji()
            run(request) { (response) in
                if case let .success(emojis, _) = response {
                    self.customEmojis = emojis
                    completion(emojis)
                } else {
                    completion([])
                }
            }
        }
    }
    
}