//
//  WalletViewModel.swift
//  GMERemittance
//
//  Created by Sujal on 2/28/18.
//  Copyright © 2018 Gobal Money Express Co. Ltd. All rights reserved.
//

import Foundation

class WalletViewModel: ModelExtension {
    
    private var gmeID: String!
    private var amount: String!
    private var message: String!
    private var mode: String!
    private var fullName: String!
    private var transactionID: String?
    
    private var walletTransferLimitMax: String!
    private var walletTransferLimitMin: String!
    
    private var parameters: [String: String] = [String: String] ()
    
    private var transaction: Transaction!
    
    private let walletTransferCode = "offer"
    private let walletRequestCode = "request"
    private let moneyRequestCode = "request"
    
    var walletLimitsFetched: Box<Bool?> = Box(nil)
    var walletActionPerformed:Box<Bool?> = Box(nil)
    
    var walletConnectionTimeOut: Box<Bool?> = Box(nil)
    
    private let user_id =  UserDefaults.standard.object(forKey: "com.gmeremit.username") as! String
    
    
}

extension WalletViewModel {
    
    
    /**
     To set control Segment Index
     - parametet segmentIndex: index of control segment
     */
    func setMode(segmentIndex: Int) {
        if segmentIndex == 0 {
            self.mode = self.walletTransferCode
        } else if segmentIndex == 1 {
            self.mode = self.walletRequestCode
        } else if segmentIndex == 2 {
               self.mode = self.moneyRequestCode
        }
    }
    
    /// To set transaction id
    func setMoneyRequestTransactionID(id: String) {
        transactionID = id
    }
    
    /**
        To get gmeId
     - returns: gme id
     */
    func getGMEID() -> String {
        return gmeID
    }
    
    /**
     To get Amount
     - returns: amount
     */
    func getAmount() -> String {
        return amount
    }
    
    /**
     To get message
     - returns: message
     */
    func getMessage() -> String {
        return message
    }

    /**
     To get mode code
     - returns: code
     */
    func getModeIndex() -> Int {
        if mode == walletTransferCode {
            return 0
        } else if mode == walletRequestCode {
            return 1
        }
        return 99
    }
    
    /**
     To get Transaction info
     - returns: transaction
     */
    func getTransactionResult() -> Transaction {
        return self.transaction
    }
    
    /**
     To get Full name
     - returns: name
     */
    func getFullName() -> String {
        return self.fullName
    }
    
    /**
     To get gme user name
     - returns: user name
     */
    func setGMEUsername(fullName: String) {
        self.fullName = fullName
    }
    
    /**
     To get max transaction limit
     - returns: transaction limit
     */
    func getMaximumTransferLimit() -> String {
        return walletTransferLimitMax
    }
    
    /**
        To set amount for Wallet trasfer
     - parameter amount: Transfer amount
     - parameter gmeID: User gmeId
     - parameter message: Transfer reason
     */
    func setParam(amount: String, gmeID: String, message: String) {
        self.amount = amount.removeSpacesTrailingPreceding().replacingOccurrences(of: " KRW", with: "", options: NSString.CompareOptions.literal, range: nil)
        self.gmeID = gmeID.removeSpacesTrailingPreceding()
        self.message = message.removeSpacesTrailingPreceding()
    }
    
    /**
        To check validataion for wallet transfer
     */
    func validateFields() -> isValid {
     
        if gmeID == user_id {
            return .InValid("Wallet action cannot be performed to own account!")
        }
        if gmeID.isBlank || amount.isBlank || message.isBlank {
            return .InValid("Please fill all the fields")
        }
        if walletTransferLimitMax == nil || walletTransferLimitMin == nil {
            return .InValid("min-max limit not fetched")
        }
        if let minAmount = Double(walletTransferLimitMin), let maxAmount = Double(walletTransferLimitMax) {
            if Double(amount)! > maxAmount || Double(amount)! < minAmount {
                return .InValid("Amount does not fall between min-max limit")
            } else {
                return .Valid
            }
        } else {
            return .InValid("Wallet min and max are non numeric")
        }
    }
    
    /**
        Wallet transfer request detail
     - parameter password: String
     - parameter moneyRequestAccepted: Bool
     */
    func getRequestParameter(password: String, moneyRequestAccepted: Bool) -> [String: String] {
        parameters.removeAll()
        if moneyRequestAccepted {
            parameters["userId"] = user_id
            parameters["transferType"] = self.mode
            parameters["transactionId"] = self.transactionID!
            parameters["txnPassword"] = password
            parameters["amount"] = self.amount
        } else {
            parameters["recipientId"] = self.gmeID
            parameters["amount"] = self.amount
            parameters["reason"] = self.message
            parameters["transferType"] = self.mode
            parameters["txnPassword"] = password
            parameters["userId"] = user_id
        }
        return parameters
    }
}

extension WalletViewModel {
    
    /**
        Api request for transaction Detail
     */
    func getTransactionInfo() {
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            RestApiMananger.sharedInstance.getTransactionInfo(param: ["countryId": "", "payoutMethodId": ""]) { result in
                
                switch result {
                case let .success(transactionInfoJSON):
                    self.walletTransferLimitMax = transactionInfoJSON["maximumTransferAmountWallet"].rawValue as! String
                    self.walletTransferLimitMin = transactionInfoJSON["minimumTransferAmountWallet"].rawValue as! String
                    self.walletLimitsFetched.value = true
                case let .failure(errorJSON):
                    self.setErrorMessage(message: errorJSON["message"].stringValue)
                    self.walletLimitsFetched.value = false
                case .updateAccessCode:
                    RestApiMananger.sharedInstance.updateAccessCode(userId: self.user_id, password: self.getLoginPassword()) {
                        result in
                        if result != "Error"{
                            let uuid = RestApiMananger.sharedInstance.getUUID()
                            UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
                            self.getTransactionInfo()
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.walletConnectionTimeOut.value = false
                }
            }
        }
    }
    
    /**
        Perform wallet action in review view page
     - parameter password: String
     - parameter moneyRequestAccepted: Bool
     */
    func performWalletAction(password: String, moneyRequestAccepted: Bool) {
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            let param = getRequestParameter(password: password, moneyRequestAccepted: moneyRequestAccepted)
            RestApiMananger.sharedInstance.performWalletAction(param: param, moneyRequestAccepted: moneyRequestAccepted) { result in
                switch result {
                case let .success(transferJSON):
                    
                    UserDefaults.standard.set(transferJSON["availableBalance"].stringValue, forKey: "com.gmeremit.balance")
                    
                    do {
                        self.transaction = try JSONDecoder().decode(Transaction.self, from: transferJSON.rawData())
                    } catch {
                       
                        self.walletActionPerformed.value = false
                    }
                    
                    self.walletActionPerformed.value = true
                case let .failure(errorJSON):
                    self.setErrorMessage(message: errorJSON["message"].stringValue)
                    self.walletActionPerformed.value = false
                case .updateAccessCode:
                    let userId = UserDefaults.standard.object(forKey: "com.gmeremit.username") as? String
                    let uuid = RestApiMananger.sharedInstance.getUUID()
                    
                    RestApiMananger.sharedInstance.updateAccessCode(userId: userId!, password: self.getLoginPassword()) {
                        result in
                        if result != "Error" {
                            UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
                            self.performWalletAction(password: password, moneyRequestAccepted: moneyRequestAccepted)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.walletConnectionTimeOut.value = false
                }
            }
        }
    }
}