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

import Foundation
import Pachyderm

class MastodonController {

    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
        }
    }
    
    private(set) lazy var cache = MastodonCache(mastodonController: self)
    
    let instanceURL: URL
    private(set) var accountInfo: LocalData.UserAccountInfo?
    
    let client: Client!
    
    var account: Account!
    var instance: Instance!

    init(instanceURL: URL) {
        self.instanceURL = instanceURL
        self.accountInfo = nil
        self.client = Client(baseURL: instanceURL)
    }
    
    func run<Result>(_ request: Request<Result>, completion: @escaping Client.Callback<Result>) {
        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: ((Account) -> Void)? = nil) {
        if account != nil {
            completion?(account)
        } else {
            let request = Client.getSelfAccount()
            run(request) { response in
                guard case let .success(account, _) = response else { fatalError() }
                self.account = account
                self.cache.add(account: account)
                completion?(account)
            }
        }
    }
    
    func getOwnInstance() {
        let request = Client.getInstance()
        run(request) { (response) in
            guard case let .success(instance, _) = response else { fatalError() }
            self.instance = instance
        }
    }
    
}