LONDON-IOS/GMERemittance/Payment/PaymentMethodViewModel.swift

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

import Foundation
import SwiftyJSON


class PaymentMethodViewModel: ModelExtension {
    
    var payoutMethodType: Box<Bool?> = Box(nil)
    var payoutBankAvailable: Box<Bool?> = Box(nil)
    var payoutBankBranchAvailable: Box<Bool?> = Box(nil)
    var cddListAvailable: Box<Int?> = Box(nil)
    
    var paymentMethodConnectionTimeOut: Box<Bool?> = Box(nil)
    
    var accountNumber: String = String()
    
    var bankNames: [String] = [String] ()
    var bankIds: [String] = [String]()
    
    var branchNames: [String] = [String] ()
    var branchIds: [String] = [String] ()
    
    var cddStateList: [String] = [String]()
    var cddStateValueList: [String] = [String]()
    
    var cddDistrictList: [String] = [String]()
    var cddDistrictValueList: [String] = [String]()
    
    var payoutModeTypeArray = [PayoutMode]()
    var payoutCashArray = [AgentModel]()
    var payoutBankDetailArray = [AgentModel]()
    var payoutBankBranchArray = [BankBranch]()
    
    let userId = UserDefaults.standard.object(forKey: "com.gmeremit.username") as? String
    
    /**
     To update account number
     - parameter acNumber: Account number
     */
    func updateAccountNumber(acNumber: String) {
        accountNumber = acNumber
    }
    
    /**
     To get bank name
     - returns: bank name list
     */
    func getBankNames() -> [String] {
        return bankNames
    }
    
    /**
     To get bank branch name
     - returns: bank  branch name list
     */
    func getBranchNames() -> [String] {
        return branchNames
    }
    
    /**
     To get a bank name
     - parameter index: position of bank in an array
     - returns: bank name
     */
    func getBankName(index: Int) -> String {
        return bankNames[index]
    }
    
    /**
     To get a bank id
     - parameter index: position of bank  id in an array
     - returns: bank id
     */
    func getBankId(index: Int) -> String {
        return bankIds[index]
    }
    
    /**
     To get a bank branch name
     - parameter index: position of bank branch in an array
     - returns: bank branch name
     */
    func getBranchName(index: Int) -> String {
        return branchNames[index]
    }
    
    /**
     To get a bank  branch id
     - parameter index: position of bank branch id in an array
     - returns: bank  branchid
     */
    func getBranchId(index: Int) -> String {
        return branchIds[index]
    }
    
    /**
     To get payout method
     - returns: payout mode
     */
    func getPayoutMethodArray() -> [PayoutMode] {
        return payoutModeTypeArray
    }
    
    /**
     To get state list
     - returns: state list
     */
    func getStateList() -> [String] {
        return cddStateList
    }
    
    /**
     To get list of state id
     - returns: state id list
     */
    func getStateValueList() -> [String] {
        return cddStateValueList
    }
    
    /**
     To get a state
     - parameter index: position of state in an array
     - returns: state
     */
    func getState(index: Int) -> String {
        return cddStateList[index]
    }
    
    /**
     To get a state id
     - parameter index: position of state id in an array
     - returns: state id
     */
    func getStateValue(index: Int) -> String {
        return cddStateValueList[index]
    }
    
    /**
     To get list of district
     - returns: district list
     */
    func getDistrictList() -> [String] {
        return cddDistrictList
    }
    
    /**
     To get list of district id
     - returns: district id list
     */
    func getDistrictValueList() -> [String] {
        return cddDistrictValueList
    }
    
    /**
     To get a district
     - parameter index: position of a district in an array
     - returns: district
     */
    func getDistrict(index: Int) -> String {
        return cddDistrictList[index]
    }
    
    /**
     To get a district id
     - parameter index: position of a district id in an array
     - returns: district id
     */
    func getDistrictValue(index: Int) -> String {
        return cddDistrictValueList[index]
    }
    
    /**
     To get Banks detail information
     - returns: list of Agents with detail information each
     */
    func getPayoutBankDetailArray() -> [AgentModel] {
        return payoutBankDetailArray
    }
    
    /**
     To get Bank branchs detail information
     - returns: list of Agent branchs with detail information each
     */
    func getPayoutBankBranchArray() -> [BankBranch] {
        return payoutBankBranchArray
    }
    
    /**
     To get Agents detail information
     - returns: list of Agents with detail information each
     */
    func getPayoutCashArray() -> [AgentModel]{
        return payoutCashArray
    }
    
    /**
     To get transfer detail information
     - parameter bankIdReferenceValue: position of bank id in an array
     - parameter branchIdReferenceValue: position of bank branch id in an array
     - returns: transfer details
     */
    func getTransferDetails(bankIdReferenceValue: Int, branchIdReferenceValue: Int) -> [String: String] {
        let transferDetails: [String: String] = ["bankId": getBankId(index: bankIdReferenceValue),
                                                 "bankName": getBankName(index: bankIdReferenceValue),
                                                 "branchId": getBranchId(index: branchIdReferenceValue),
                                                 "branchName": getBranchName(index: branchIdReferenceValue),
                                                 "accountNumber": accountNumber]
        return transferDetails
    }
    
    /**
     To get a country payout mode i.e cash , bank or home delivery
     - Parameter country id: counrty id of selected country
     */
    func fetchCountryPayoutMode(countryId: String) {
        
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            
            self.payoutModeTypeArray.removeAll()
            
            RestApiMananger.sharedInstance.getCountryPayoutMode(countryId: countryId) { result in
                switch result {
                case let .success(countryPayoutJSON):
                    if countryPayoutJSON.count > 0{
                        for i in 0 ... (countryPayoutJSON.count-1) {
                            do {
                                let payout = try JSONDecoder().decode(PayoutMode.self, from: countryPayoutJSON[i].rawData())
                                self.payoutModeTypeArray.append(payout)
                            } catch {
                                self.payoutMethodType.value = false
                            }
                        }
                    }
                    self.payoutMethodType.value = true
                case let .failure(errorJSON):
                    self.setErrorMessage(message: errorJSON["message"].stringValue)
                case .updateAccessCode:
                    RestApiMananger.sharedInstance.updateAccessCode(userId: self.userId!, password: self.getLoginPassword()) {
                        result in
                        if result != "Error"{
                            let uuid = RestApiMananger.sharedInstance.getUUID()
                            UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
                            self.fetchCountryPayoutMode(countryId: countryId)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.paymentMethodConnectionTimeOut.value = false
                }
            }
        }
    }
    
    /**
     To get bank detail with payout mode
     - parameter countryId: country id
     - parameter payoutMethodId: id of payout method
     */
    func fetchPayoutBankDetail(countryId: String,payoutMethodId: String){
        if payoutMethodId == "1" {
            payoutCashArray.removeAll()
        } else if payoutMethodId == "2" {
            payoutBankDetailArray.removeAll()
        }
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            RestApiMananger.sharedInstance.getPayoutBankDetail(countryId: countryId, payoutMethodId: payoutMethodId){
                result in
                switch result{
                case let .success(bankDetailJSON):
                    guard bankDetailJSON.count > 0 else {
                        return
                    }
                    self.setPayoutBankDetails(bankDetailJSON: bankDetailJSON, payoutMethodId: payoutMethodId)
                    self.payoutBankAvailable.value = true
                case let .failure(errorJSON):
                    self.setErrorMessage(message: errorJSON["message"].stringValue)
                    self.payoutBankAvailable.value = false
                case .updateAccessCode:
                    RestApiMananger.sharedInstance.updateAccessCode(userId: self.userId!, password: self.getLoginPassword()) {
                        result in
                        if result != "Error"{
                            let uuid = RestApiMananger.sharedInstance.getUUID()
                            UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
                            self.fetchPayoutBankDetail(countryId: countryId, payoutMethodId: payoutMethodId )
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.paymentMethodConnectionTimeOut.value = false
                }
            }
        }
    }
    
    /// set up of payout bank detail
    func setPayoutBankDetails(bankDetailJSON: JSON,payoutMethodId: String ){
        if !bankDetailJSON.isEmpty {
            for i in 0 ... (bankDetailJSON.count-1) {
                do {
                    let bankDetail = try JSONDecoder().decode(AgentModel.self, from: bankDetailJSON[i].rawData())
                    if payoutMethodId == "1" {
                        payoutCashArray.append(bankDetail)
                    } else if payoutMethodId == "2"{
                        payoutBankDetailArray.append(bankDetail)
                    }
                } catch let err {
                    self.setErrorMessage(message: err as! String)
                    self.payoutBankAvailable.value = false
                }
            }
        }
    }
    
    /**
     To get bank branch detail with payout mode
     - parameter countryId: country id
     - parameter payoutId: id of payout ie.bank payout id
     */
    func fetchPayoutBankBranchDetail(countryId: String, payoutId: String ){
        payoutBankBranchArray.removeAll()
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            RestApiMananger.sharedInstance.getPayoutBankBranchDetail(countryId: countryId, payoutId: payoutId){
                result in
                switch result{
                case let .success(bankBranchDetailJSON):
                    guard bankBranchDetailJSON.count > 0 else {
                        return
                    }
                    for i in 0 ... (bankBranchDetailJSON.count-1) {
                        do {
                            let bankBranchDetail = try JSONDecoder().decode(BankBranch.self, from: bankBranchDetailJSON[i].rawData())
                            self.payoutBankBranchArray.append(bankBranchDetail)
                            
                        } catch let err {
                            self.setErrorMessage(message: err as! String)
                            self.payoutBankBranchAvailable.value = false
                        }
                    }
                    self.payoutBankBranchAvailable.value = true
                    
                case let .failure(errorJSON):
                    self.setErrorMessage(message: errorJSON["message"].stringValue)
                    self.payoutBankBranchAvailable.value = false
                case .updateAccessCode:
                    RestApiMananger.sharedInstance.updateAccessCode(userId: self.userId!, password: self.getLoginPassword()) {
                        result in
                        if result != "Error"{
                            let uuid = RestApiMananger.sharedInstance.getUUID()
                            UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
                            self.fetchPayoutBankBranchDetail(countryId: countryId, payoutId: payoutId)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.paymentMethodConnectionTimeOut.value = false
                }
            }
        }
    }
    
    /**
     To get cdd list such as  occupation , relation, state ect
     - parameter cddName: cddcode
     - parameter param: cdd info
     */
    func fetchCDDListFor(cddName: String, param: [String: String]) {
        
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            
            RestApiMananger.sharedInstance.getCDDListFor(cddCode: cddName, param: param) { result in
                switch result {
                case let .success(cddJSON):
                    if cddName == cddCode.Province.rawValue {
                        self.cddStateValueList.removeAll()
                        self.cddStateList.removeAll()
                    } else if cddName == cddCode.District.rawValue {
                        self.cddDistrictList.removeAll()
                        self.cddDistrictValueList.removeAll()
                    }
                    guard cddJSON.count > 0 else {
                        return
                    }
                    for i in 0 ... (cddJSON.count-1) {
                        do {
                            let cddNameValuePair = try JSONDecoder().decode(Cdd.self, from: cddJSON[i].rawData())
                            switch cddName {
                            case cddCode.Province.rawValue:
                                self.cddStateList.append(cddNameValuePair.name)
                                self.cddStateValueList.append(cddNameValuePair.value)
                                
                            case cddCode.District.rawValue:
                                self.cddDistrictList.append(cddNameValuePair.name)
                                self.cddDistrictValueList.append(cddNameValuePair.value)
                                
                            default:
                                return
                            }
                            
                        } catch {
                            self.setErrorMessage(message: "Error decoding JSON")
                            break
                        }
                    }
                    switch cddName {
                    case cddCode.Province.rawValue:
                        self.cddListAvailable.value = 2
                    case cddCode.District.rawValue:
                        self.cddListAvailable.value = 3
                    default:
                        return
                        
                    }
                case let .failure(errorJSON):
                    self.setErrorMessage(message: errorJSON["message"].stringValue)
                    self.cddListAvailable.value = 0
                case .updateAccessCode:
                    RestApiMananger.sharedInstance.updateAccessCode(userId: self.userId!, password: self.getLoginPassword()) {
                        result in
                        if result != "Error"{
                            
                            let uuid = RestApiMananger.sharedInstance.getUUID()
                            
                            UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
                            self.fetchCDDListFor(cddName: cddName, param: param)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.paymentMethodConnectionTimeOut.value = false
                }
            }
        }
    }
}