//
//  AccountServiceManual.swift
//  PayCash
//
//  Created by Igor on 05.03.2021.
//  Copyright © 2021 AM. All rights reserved.
//

import Foundation
import EosioSwift

extension Account.Service {
    class Manual: Common.Service.Provider {
        
        private(set) var accounts = [Account.Model.Add]()
        private var requests = 0

        func fetch(privateKey: String, _ completion: @escaping Completion.Network) {
            guard let publicKey = privateKey.publicKey() else {
                completion(.error(L10n.Error.Accounts.keyInvalid))
                return
            }
            Network.accounts.fetch(publicKey: publicKey) { (collection) in
                if (collection.isEmpty) {
                    completion(.error(L10n.Error.Accounts.empty))
                } else {
                    self.requests = collection.count
                    self.accounts = []
                    collection.forEach { username in
                        DispatchQueue.global().async {
                            Network.accounts.account(username, completion: { response in
                                
                                guard let accountInfo = response else {
                                    completion(.error(L10n.Error.Accounts.empty))
                                    return
                                }
                                let newAccounts = self.prepareAccountInfo(username: username, publicKey: publicKey, accountPermissions: accountInfo.permissions)
                                self.accounts += newAccounts
                                self.requests -= 1
                                
                                if (self.requests == 0) {
                                    DispatchQueue.main.async { completion(nil) }
                                }
                            })
                        }
                    }
                }
            }
        }
        
        private func prepareAccountInfo(username: String, publicKey: String, accountPermissions: [Permission]) -> [Account.Model.Add] {
            
            let addedAccounts = Accounts().collection
            let permissions = accountPermissions
                .filter { $0.requiredAuth.keys.first?.key == publicKey }
                .sorted { $0.permName > $1.permName }
            
            var accounts: [Account.Model.Add] = []
            permissions.forEach { permission in
                let isAccountAdded = addedAccounts.contains(where: {
                    $0.username == username && $0.keyType.rawValue == permission.permName
                })
                if (permission.permName == Account.KeyType.owner.rawValue) {
                    accounts.append(Account.Model.Add(username: username, permission: permission, isAdded: isAccountAdded))
                }
                let hasAddedOwnerKey = accounts.contains(where: { account in
                    account.username == username &&
                    account.permission.requiredAuth.keys.first?.key == permission.requiredAuth.keys.first?.key
                })
                if (permission.permName != Account.KeyType.owner.rawValue && !hasAddedOwnerKey) {
                    accounts.append(Account.Model.Add(username: username, permission: permission, isAdded: isAccountAdded))
                }
            }
            return accounts
        }
    }
}