//
//  APIRouter.swift
//  GME Remit
//
//  Created by InKwon James Kim on 09/08/2019.
//  Copyright © 2019 Gobal Money Express Co. Ltd. All rights reserved.
//

import Foundation
import Alamofire
import Localize_Swift
import ObjectMapper

import RxSwift

class APIManager {
    static let shared = APIManager()
    let manager: SessionManager
    
    init() {
        let configure = URLSessionConfiguration.default
        configure.timeoutIntervalForRequest = 300.0
        configure.timeoutIntervalForResource = 300.0
        
        manager = Alamofire.SessionManager(configuration: configure)
    }
}

enum APIRouter {
    // MARK: - Login
    case accesscode(username: String, password: String)
    case customerProfile(firebaseToken: String)
    
    // MARK: - Register
    case requestOTP(mobileNumber: String)
    case submitOTP(otp: String)
    case customerRegister(registerModel: RegisterRequestModel, firebaseToken: String)
    case passwordReset(userName: String)
    case validation(userName: String, idNumber: String, idType: String)
    case countriesServices
    case calculateDefExRate(model: ExchangeRateRequestModel)
    
    // MARK: - Existing User Registration
    case oldUserAccessRequest(idNumber: String, mobileNumber: String, dob: String)
    case oldUserRegister(registerModel: OldUserRegisterRequestModel, firebaseToken: String)
    case loadExistingUserInformation
    case submitExistingCustomerKYC(model: KYCSaveInformation)
    
    // MARK: - New User Registration
    case verifyIdNumber(id: String, type: String)
    case newUserRegister(model: NewUserRegisterModel, fcmToken: String)
    case submitKYC(model: KYCSaveInformation)
    
    // MARK: - Receiver
    case fetchRecipients(senderID: String)
    case dynamicReceiver(username: String, countryID: String, serviceTypeID: String)
    case fetchCountriesAndServiceTypes(username: String)
    case addRecipient(senderID: String, recipient: Recipient)
    case editRecipient(senderID: String, recipient: Recipient)
    case deleteRecipient(senderID: String, recipientID: String)
    case fetchBranches(countryCode: String, bankID: String, branchName: String)
    case validateAccount(validateModel: ValidateAccountRequest)
    
    // MARK: - Inbound
    case fetchInboundTransactionHistory(from: String, to: String)
    
    // MARK: - New Registration
    case loadKYCInformation
//    case saveKYCInformation(model: KYCSave)
    case requestPennyTestAtRegister(resend: String)
    case pennyTestSubmitAtRegister(accountNumber: String, certNumber: String)
    case fetchKFTCParameterForRegister
    case customerInfoAgree(_ flag: Bool)
    case checkInfoAgree
    
    // MARK: - New Registration
    case getNotifyInfo
    case getNotifyDetailInfo(idx: String)
    
    // MARK: - Edit Profile
    case profileCheckPassword(model: ChangePersonalInformationModel, target: String)
    case profileValidationOTP(OTPPassword: String)
    case profileChangeInformation(newValue: String, target: String)
    case resendOTPForChangeProfileInformation(newValue: String)
    case fetchPersonalInformation
    
    // MARK: - Transaction
    case searchTxnByControlNumber(controlNumber: String)
    case redeemCashPayment(controlNumber: String, txnId: String, password: String)
    
    //Mark: - Withdraw From Wallet
    case withdrawWalletRequest(amount: String)
    case withdrawFromWallet(txnId: String,amount: String, password: String)
}

// MARK: - Request
extension APIRouter: ApiServiceType {
    private var manager: SessionManager {
        return APIManager.shared.manager
    }
    
    private var uuid: String {
        guard let uuid = GMEDB.shared.app.string(.uuid) else {
            let uuid = UUID().uuidString
            GMEDB.shared.app.set(uuid, .uuid)
            return uuid
        }
        
        return uuid
    }
    
    private var beforeLoginHeader: [String: String] {
        let currentLanguage = Localize.currentLanguage()
        let lang = Utility.getLanguageHeader(for: currentLanguage)
        let authValue = "172017F9EC11222E8107142733:QRK2UM0Q:\(uuid)".toBase64()
        
        return [
            "Authorization": "Basic \(authValue)",
            "GME-TOKEN" : "39587YT398@FBQOW8RY3#948R7GB@CNEQW987GF87$TD18$1981..919@@##joghndvberteiru",
            "Content-Type": "application/json",
            "lang" : lang
        ]
    }
    
    private var afterLoginHeader: [String: String] {
        let accessCode = GMEDB.shared.user.string(.accessCode) ?? ""
        let currentLanguage = Localize.currentLanguage()
        let lang = Utility.getLanguageHeader(for: currentLanguage)
        
        return [
            "Authorization": "Bearer " + accessCode,
            "GME-TOKEN" : "39587YT398@FBQOW8RY3#948R7GB@CNEQW987GF87$TD18$1981..919@@##joghndvberteiru",
            "Content-Type": "application/json",
            "clientId": Utility.getMyKftcClientId(),
            "lang" : lang
        ]
    }
    
    func json(
        encoding: ParameterEncoding = JSONEncoding.default,
        needsAuthorization: Bool = true,
        success: @escaping () -> Void,
        failure: @escaping (Error) -> Void
    ) {
        guard
            let isReachable = NetworkReachabilityManager()?.isReachable,
            isReachable else {
                let error = NSError(
                    domain: "NETWORK_REACHABILITY_DOMAIN",
                    code: -99,
                    message: "No Internet connection found. Check your connection."
                )
                return failure(error)
        }
        
        manager.request(
            self.endpoint,
            method: self.method,
            parameters: self.parameters,
            encoding: encoding,
            headers: needsAuthorization ? afterLoginHeader : beforeLoginHeader
        ).handle(
            success: { (response: ResponseContainer<Void>) in
                if (response.errorCode ?? "") != "0" {
                    let code = Int(response.errorCode ?? "1") ?? 1
                    let error = NSError(domain: "Network", code: code, message: response.message ?? "")
                    failure(error)
                } else {
                    success()
                }
        },
            failure: failure
        )
    }
    
    func json<Element>(
        encoding: ParameterEncoding = JSONEncoding.default,
        needsAuthorization: Bool = true,
        success: @escaping (Element) -> Void,
        failure: @escaping (Error) -> Void
    ) {
        guard
            let isReachable = NetworkReachabilityManager()?.isReachable,
            isReachable else {
                let error = NSError(
                    domain: "NETWORK_REACHABILITY_DOMAIN",
                    code: -99,
                    message: "No Internet connection found. Check your connection."
                )
                return failure(error)
        }
        
        manager.request(
            self.endpoint,
            method: self.method,
            parameters: self.parameters,
            encoding: encoding,
            headers: needsAuthorization ? afterLoginHeader : beforeLoginHeader
        ).handle(
            success: { (response: ResponseContainer<Element>) in
                if (response.errorCode ?? "") != "0" {
                    let code = Int(response.errorCode ?? "1") ?? 1
                    let error = NSError(domain: "Network", code: code, message: response.message ?? "")
                    failure(error)
                } else {
                    guard let data = response.data else {
                        let error = NSError(domain: "Network", code: 0, message: "Data is nil")
                        failure(error)
                        return
                    }
                    success(data)
                }
        },
            failure: failure
        )
    }
    
    func json<Element: Mappable>(
        encoding: ParameterEncoding = JSONEncoding.default,
        needsAuthorization: Bool = true,
        success: @escaping (Element) -> Void,
        failure: @escaping (Error) -> Void
    ) {
        guard
            let isReachable = NetworkReachabilityManager()?.isReachable,
            isReachable else {
                let error = NSError(
                    domain: "NETWORK_REACHABILITY_DOMAIN",
                    code: -99,
                    message: "No Internet connection found. Check your connection."
                )
                return failure(error)
        }
        
        manager.request(
            self.endpoint,
            method: self.method,
            parameters: self.parameters,
            encoding: encoding,
            headers: needsAuthorization ? afterLoginHeader : beforeLoginHeader
        )
            .handle(
                success: { (response: ResponseContainerObject<Element>) in
                    if (response.errorCode ?? "") != "0" {
                        let code = Int(response.errorCode ?? "1") ?? 1
                        let error = NSError(domain: "Network", code: code, message: response.message ?? "")
                        failure(error)
                    } else {
                        guard let data = response.data else {
                            let error = NSError(domain: "Network", code: 0, message: "Data is nil")
                            failure(error)
                            return
                        }
                        success(data)
                    }
            },
                failure: failure
        )
    }
    
    func json<Element: Mappable>(
        encoding: ParameterEncoding = JSONEncoding.default,
        needsAuthorization: Bool = true,
        success: @escaping ([Element]) -> Void,
        failure: @escaping (Error) -> Void
    ) {
        guard
            let isReachable = NetworkReachabilityManager()?.isReachable,
            isReachable else {
                let error = NSError(
                    domain: "NETWORK_REACHABILITY_DOMAIN",
                    code: -99,
                    message: "No Internet connection found. Check your connection."
                )
                return failure(error)
        }
        
        manager.request(
            self.endpoint,
            method: self.method,
            parameters: self.parameters,
            encoding: encoding,
            headers: needsAuthorization ? afterLoginHeader : beforeLoginHeader
        )
            .handle(
                success: { (response: ResponseContainerArray<Element>) in
                    if (response.errorCode ?? "") != "0" {
                        let code = Int(response.errorCode ?? "1") ?? 1
                        let error = NSError(domain: "Network", code: code, message: response.message ?? "")
                        failure(error)
                    } else {
                        guard let data = response.data else {
                            let error = NSError(domain: "Network", code: 0, message: "Data is nil")
                            failure(error)
                            return
                        }
                        success(data)
                    }
            },
                failure: failure
        )
    }
    
    func request<T: Mappable>(
        encoding: ParameterEncoding = JSONEncoding.default,
        needsAuthorization: Bool = true,
        success: @escaping (T) -> Void,
        failure: @escaping (Error) -> Void
    ) {
        guard
            let isReachable = NetworkReachabilityManager()?.isReachable,
            isReachable else {
                let error = NSError(
                    domain: "NETWORK_REACHABILITY_DOMAIN",
                    code: -99,
                    message: "No Internet connection found. Check your connection."
                )
                return failure(error)
        }
        
        manager.request(
            self.endpoint,
            method: self.method,
            parameters: self.parameters,
            encoding: encoding,
            headers: needsAuthorization ? afterLoginHeader : beforeLoginHeader
        ).handle(success: success, failure: failure)
    }
    
    func kftcRequest<T: Mappable>(
        header: [String: String],
        encoding: ParameterEncoding = JSONEncoding.default,
        success: @escaping (T) -> Void,
        failure: @escaping (Error) -> Void
    ) {
        guard
            let isReachable = NetworkReachabilityManager()?.isReachable,
            isReachable else {
                let error = NSError(
                    domain: "NETWORK_REACHABILITY_DOMAIN",
                    code: -99,
                    message: "No Internet connection found. Check your connection."
                )
                return failure(error)
        }
        
        manager.request(
            self.endpoint,
            method: self.method,
            parameters: self.parameters,
            encoding: encoding,
            headers: header
        ).handle(success: success, failure: failure)
        
    }
    
    func requestMultipart<T: Mappable>(
        images: [String: Data],
        encoding: Alamofire.ParameterEncoding = URLEncoding.default,
        needsAuthorization: Bool = true,
        success: @escaping (T) -> Void,
        failure: @escaping (Error) -> Void
    ) {
        guard
            let isReachable = NetworkReachabilityManager()?.isReachable,
            isReachable else {
                let error = NSError(
                    domain: "NETWORK_REACHABILITY_DOMAIN",
                    code: -99,
                    message: "No Internet connection found. Check your connection."
                )
                return failure(error)
        }
        
        manager.upload(
            multipartFormData: { multipartFormData in
                if !images.isEmpty {
                    images.forEach({ (data) in
                        multipartFormData.append(
                            data.value,
                            withName: data.key,
                            fileName: data.key + ".jpeg",
                            mimeType: "image/jpeg"
                        )
                    })
                    
                }
                print("Params: \(self.parameters ?? [:])")
                self.parameters?.forEach { (params) in
                    multipartFormData
                        .append("\(params.value)".data(using: String.Encoding.utf8)!, withName: params.key as String)
                }
        },
            usingThreshold: UInt64(),
            to: self.endpoint,
            method: self.method,
            headers: needsAuthorization ? afterLoginHeader : beforeLoginHeader,
            encodingCompletion: { encodingResult in
                switch encodingResult {
                case .success(let upload, _, _):
                    upload.handle(success: success, failure: failure)
                case .failure:
                    let error = NSError(
                        domain: "NETWORK_REACHABILITY_DOMAIN",
                        code: -99,
                        message: "No Internet connection found. Check your connection."
                    )
                    failure(error)
                }
        }
        )
    }
}

// MARK: - Endpoint
extension APIRouter {
    private var endpoint: String {
        switch self {
        case .accesscode:
            return "\(baseUrl)/users/access-code"
        case .customerProfile:
            return "\(baseUrl)/mobile/CustomerProfile"
        case .requestOTP:
            return "\(baseUrl)/mobile/requestOTP"
        case .submitOTP:
            return "\(baseUrl)/mobile/submitOTP"
        case .customerRegister:
            return "\(baseUrlWithoutVersion)v3/mobile/customerRegister"
        case .passwordReset:
            return "\(baseUrl)/mobile/passwordReset"
        case .validation:
            return "\(baseUrlWithoutVersion)v3/validation"
        case .oldUserAccessRequest:
            return "\(baseUrlWithoutVersion)v1/mobile/oldUserAccessRequest"
        case .countriesServices:
            return "\(baseUrl)/mobile/countriesServices"
        case .calculateDefExRate:
            return "\(baseUrl)/mobile/calculateDefExRate"
        case .dynamicReceiver(let username, let countryID, let serviceType):
            let path = "\(username)/dynamicField?countryId=\(countryID)&serviceType=\(serviceType)"
            return "\(baseUrlWithoutVersion)v3/mobile/receiver/\(path)"
        case .fetchRecipients(let senderID):
            return "\(baseUrlWithoutVersion)v3/mobile/\(senderID)/receiverinfo"
        case .fetchCountriesAndServiceTypes(let username):
            return "\(baseUrlWithoutVersion)v3/mobile/\(username)/FetchCountriesAndServiceTypes"
        case .addRecipient(let senderID, _):
            return "\(baseUrlWithoutVersion)v3/mobile/\(senderID)/receiverinfo/add"
        case .editRecipient(let senderID, let recipient):
            let recipientID = recipient.receiverID ?? ""
            return "\(baseUrlWithoutVersion)v3/mobile/\(senderID)/receiverinfo/modify/\(recipientID)"
        case .deleteRecipient(let senderID, let recipientID):
            return "\(baseUrlWithoutVersion)v3/mobile/\(senderID)/receiverinfo/remove/\(recipientID)"
        case .fetchBranches(let countryCode, let bankID, let branchName):
            return "\(baseUrl)/mobile/sendmoney/load/branch/\(countryCode)/\(bankID)/?search=\(branchName)"
        case .validateAccount:
            return "\(baseUrl)/mobile/sendmoney/validation/account"
        case .fetchInboundTransactionHistory:
            let senderId = GMEDB.shared.user.string(.senderId) ?? ""
            return "\(baseUrl)/inbound/mobile/tranHistory/\(senderId)"
        case .loadKYCInformation:
            let userID = GMEDB.shared.user.string(.userId) ?? ""
            return "\(baseUrlWithoutVersion)v4/mobile/loadform/\(userID)/kyc"
        case .loadExistingUserInformation:
            let userID = GMEDB.shared.user.string(.userId) ?? ""
            return "\(baseUrlWithoutVersion)v4/mobile/loadform/\(userID)/kycExistingCustomer"
//        case .saveKYCInformation:
//            return "\(baseUrlWithoutVersion)/v4/mobile/RegisterKyc"
        case .submitKYC:
            return "\(baseUrlWithoutVersion)v1/mobile/RegisterKyc"
        case .submitExistingCustomerKYC:
        return "\(baseUrlWithoutVersion)v1/mobile/RegisterKycExistingCustomer"
        case .requestPennyTestAtRegister(let resend):
            let userID = GMEDB.shared.user.string(.userId) ?? ""
            return "\(baseUrl)/mobile/pennytest/start/\(userID)?reSendCode=\(resend)"
        case .fetchKFTCParameterForRegister:
            let userID = GMEDB.shared.user.string(.userId) ?? ""
            return "\(baseUrlWithoutVersion)/v4/GetKftcParameters/\(userID)"
        case .pennyTestSubmitAtRegister:
            return "\(baseUrl)/mobile/pennytest/getcertified"
        case .customerInfoAgree(let flag):
            let userID = GMEDB.shared.user.string(.userId) ?? ""
            return "\(baseUrlWithoutVersion)v3/mobile/customerInfoAgree/\(userID)?agreeYn=\(flag ? "Y" : "N")"
        case .checkInfoAgree:
            let userID = GMEDB.shared.user.string(.userId) ?? ""
            return "\(baseUrl)/mobile/CheckInfoAgree/\(userID)"
        case .getNotifyInfo:
            return "\(baseUrl)/mobile/GetNotifyInfo"
        case .getNotifyDetailInfo:
            return "\(baseUrl)/mobile/GetNotifyDetailInfo"
        case .profileCheckPassword:
            return "\(baseUrlWithoutVersion)v1/mobile/CheckPassword"
        case .profileValidationOTP:
            return "\(baseUrlWithoutVersion)v1/mobile/ValidationOTP"
        case .profileChangeInformation:
            return "\(baseUrlWithoutVersion)v1/mobile/ChangeInformation"
        case .resendOTPForChangeProfileInformation:
            return "\(baseUrlWithoutVersion)v1/mobile/ReSendOTP"
        case .fetchPersonalInformation:
            return "\(baseUrlWithoutVersion)v1/mobile/ProfilepersonalInformation"
        case .searchTxnByControlNumber:
            return "\(baseUrl)/mobile/searchTxnByControlNumber"
        case .redeemCashPayment:
            return "\(baseUrl)/mobile/redeemCashPayment"
        case .withdrawWalletRequest:
            return "\(baseUrl)/mobile/withdrawWalletRequest"
        case .withdrawFromWallet:
            return "\(baseUrl)/mobile/withdrawFromWallet"
        case .oldUserRegister:
            return "\(baseUrlWithoutVersion)v1/mobile/oldUserRegister"
        case .verifyIdNumber:
            return "\(baseUrlWithoutVersion)v3/validation"
        case .newUserRegister:
            return "\(baseUrlWithoutVersion)v1/mobile/newUserRegister"
        }
    }
}

// MARK: - Method
extension APIRouter {
    private var method: HTTPMethod {
        switch self {
        case .accesscode:
            return .post
        case .customerProfile:
            return .post
        case .requestOTP:
            return .post
        case .submitOTP:
            return .post
        case .customerRegister:
            return .post
        case .passwordReset:
            return .post
        case .validation:
            return .post
        case .oldUserAccessRequest:
            return .post
        case .countriesServices:
            return .get
        case .calculateDefExRate:
            return .post
        case .dynamicReceiver:
            return .get
        case .fetchRecipients:
            return .get
        case .fetchCountriesAndServiceTypes:
            return .get
        case .addRecipient:
            return .post
        case .editRecipient:
            return .post
        case .deleteRecipient:
            return .post
        case .fetchBranches:
            return .post
        case .validateAccount:
            return .post
        case .fetchInboundTransactionHistory:
            return .post
        case .loadKYCInformation:
            return .get
        case .loadExistingUserInformation:
            return .get
//        case .saveKYCInformation:
//            return .post
        case .submitKYC:
            return .post
        case .submitExistingCustomerKYC:
            return .post
        case .requestPennyTestAtRegister:
            return .post
        case .fetchKFTCParameterForRegister:
            return .get
        case .pennyTestSubmitAtRegister:
            return .post
        case .customerInfoAgree:
            return .get
        case .checkInfoAgree:
            return .post
        case .getNotifyInfo:
            return .post
        case .getNotifyDetailInfo:
            return .post
        case .profileCheckPassword:
            return .post
        case .profileValidationOTP:
            return .post
        case .profileChangeInformation:
            return .post
        case .resendOTPForChangeProfileInformation:
            return .post
        case .fetchPersonalInformation:
            return .post
        case .searchTxnByControlNumber:
            return .post
        case .redeemCashPayment:
            return .post
        case .withdrawWalletRequest, .withdrawFromWallet:
            return .post
        case .oldUserRegister:
            return .post
        case .verifyIdNumber:
            return .post
        case .newUserRegister:
            return .post
     
        }
    }
}

// MARK: - Parameter
extension APIRouter {
    private var parameters: Parameters? {
        switch self.method {
        case .post:
            switch self {
            case .accesscode(let username, let password):
                return [
                    "userId": username,
                    "password": password
                ]
                
            case .customerProfile(let firebaseToken):
                return [
                    "userId" : Utility.getMyUserName(),
                    "uuid": self.uuid,
                    "appVersion": Utility.getAppVersion() ?? "",
                    "phoneBrand": UIDevice.modelName,
                    "phoneOs": Utility.getPhoneOs(),
                    "fcmId": firebaseToken,
                    "osVersion": Utility.getOsVersion()
                ]
                
            case .requestOTP(let mobileNumber):
                return ["mobileNumber" : mobileNumber]
                
            case .submitOTP(let otp):
                return [
                    "mobileNumber" : GMEDB.shared.register.string(.mobileNumber) ?? "",
                    "OTP" : otp
                ]
                
            case .customerRegister(let registerModel, let firebaseToken):
                return [
                    "username": registerModel.username ?? "",
                    "password": registerModel.encryptedPassword ?? "",
                    "nativecountry": registerModel.nativeCountry ?? "",
                    "mobilenumber": registerModel.mobileNumber ?? "",
                    "clientId": Utility.getCliendId(),
                    "uuid": self.uuid,
                    "appVersion": Utility.getAppVersion() ?? "",
                    "phoneBrand": UIDevice.modelName,
                    "phoneOs": Utility.getPhoneOs(),
                    "fcmId": firebaseToken,
                    "osVersion": Utility.getOsVersion(),
                    "referenceId": GMEDB.shared.register.string(.referenceId) ?? ""
                ]
                
            case .oldUserRegister(let registerModel, let firebaseToken):
                return [
                    "UserId": registerModel.userId ?? "",
                    "referenceId": GMEDB.shared.register.string(.referenceId) ?? "",
                    "Password": registerModel.password ?? "",
                    "ConfirmPassword": registerModel.confirmPassword ?? "",
                    "TxnPin": registerModel.txnPin ?? "",
                    "ConfirmTxnPin": registerModel.confirmTxnPin ?? "",
                    "clientId": GMEDB.shared.generatedUserId.string(.generatedUserId) ?? "",
                    "uuid": self.uuid,
                    "appVersion": Utility.getAppVersion() ?? "",
                    "phoneBrand": UIDevice.modelName,
                    "phoneOS": Utility.getPhoneOs(),
                    "fcmId": firebaseToken,
                    "osVersion": Utility.getOsVersion(),
                    "referralCode": registerModel.referralCode ?? ""
                ]
                
            case .newUserRegister(let model, let fcmToken):
                return [
                    "ResidenceCardNumber": GMEDB.shared.user.string(.userId) ?? "",
                    "UserId": model.userId ?? "",
                    "Password": model.password ?? "",
                    "ConfirmPassword": model.confirmPassword ?? "",
                    "clientId": Utility.getCliendId(),
                    "uuid": self.uuid,
                    "appVersion": Utility.getAppVersion() ?? "",
                    "phoneBrand": UIDevice.modelName,
                    "phoneOS": Utility.getPhoneOs(),
                    "fcmId": fcmToken,
                    "osVersion": Utility.getOsVersion(),
                    "referralCode": model.referralCode ?? ""
                ]
                
            case .passwordReset(let userName):
                return ["username": userName]
                
            case .validation(let userName, let idNumber, let idType):
                return [
                    "Username": userName,
                    "IdNumber": idNumber,
                    "IdType": idType
                ]
                
            case .oldUserAccessRequest(let idNumber, let mobileNumber, let dob):
                return [
                    "IdNumber": idNumber,
                    "MobileNumber": mobileNumber,
                    "Dob": dob
                ]
            
            case .verifyIdNumber(let id, let type):
                return [
                    "type": type,
                    "idnumber": id
                ]
            
            case .calculateDefExRate(let model):
                return model.serialize()
                
            case .dynamicReceiver:
                return nil
                
            case .addRecipient(_, let recipient):
                let paymentMethod = [
                    "id": recipient.paymentMethod?.id ?? "",
                    "name": recipient.paymentMethod?.name ?? "",
                    "currency": recipient.paymentMethod?.currency ?? [],
                    "localizedName": recipient.paymentMethod?.localizedName ?? ""
                    ] as [String : Any]
                
                let branch = [
                    "id": recipient.agent?.branch?.id ?? "",
                    "name": recipient.agent?.branch?.name ?? "",
                    "localizedName": recipient.agent?.branch?.name ?? ""
                ]
                
                let agent = [
                    "id": recipient.agent?.id ?? "",
                    "name": recipient.agent?.name ?? "",
                    "currency": recipient.agent?.currency ?? [],
                    "localizedName": recipient.agent?.localizedName ?? "",
                    "branch": branch,
                    "accountNo": recipient.agent?.accountNumber ?? ""
                    ] as [String : Any]
                
                return [
                    "firstName": recipient.firstName ?? "",
                    "middleName": recipient.middleName ?? "",
                    "lastName": recipient.lastName ?? "",
                    "localFirstName": recipient.localFirstName ?? "",
                    "localMiddleName": recipient.localMiddleName ?? "",
                    "localLastName": recipient.localLastName ?? "",
                    "localFullName": recipient.localFullName ?? "",
                    "paymentMethod": paymentMethod,
                    "agent": agent,
                    "receiverId": recipient.receiverID ?? "",
                    "country": recipient.country ?? "",
                    "countryId": recipient.countryID ?? "",
                    "countryCode": recipient.countryCode ?? "",
                    "address": recipient.address ?? "",
                    "state": recipient.state ?? "",
                    "stateId": recipient.stateID ?? "",
                    "city": recipient.city ?? "",
                    "email": recipient.email ?? "",
                    "mobile": recipient.mobile ?? "",
                    "relationship": recipient.relationship ?? "",
                    "relationshipId": recipient.relationshipID ?? "",
                    "district": recipient.district ?? "",
                    "districtId": recipient.districtID ?? "",
                    "purposeOfRemit": recipient.purposeOfRemit ?? "",
                    "purposeOfRemitId": recipient.purposeOfRemitID ?? "",
                    "fullName": recipient.fullName ?? "",
                    "idType": recipient.idType ?? "",
                    "idNumber": recipient.idNumber ?? "",
                    "nativeCountry": recipient.nativeCountry ?? "",
                    "nativeCountryID": recipient.nativeCountryID ?? "",
                    "nativeCountryCode": recipient.nativeCountryCode ?? ""
                ]
                
            case .editRecipient(let senderID, let recipient):
                return APIRouter.addRecipient(senderID: senderID, recipient: recipient).parameters
                
            case .validateAccount(let validateModel):
                return [
                    "IdType" : "1",
                    "IdNumber": "",
                    "CustomerFirstName": "",
                    "CustomerLastName": "",
                    "ReceiverFirstName": validateModel.firstName,
                    "ReceiverLastName": validateModel.lastName,
                    "Country": validateModel.country?.countryCode ?? "",
                    "AccountType": validateModel.accountType,
                    "IssuerCode": validateModel.bank?.code ?? "",
                    "AccountNo": validateModel.accountNumber,
                    "BankCode": validateModel.branch?.code ?? validateModel.bank?.code ?? "",
                    "Amount": validateModel.amount,
                    "PayoutPartner": validateModel.payoutPartner,
                    "ProcessId": "",
                    "BankId": validateModel.bank?.id ?? "",
                    "ReceiverCountryId": validateModel.country?.countryId ?? "",
                    "deliveryMethodId": validateModel.paymentMethod?.id ?? ""
                ]
                
            case .fetchInboundTransactionHistory(let from, let to):
                return [
                    "FromDate": from,
                    "ToDate": to,
                    "tranId": ""
                ]
    /*
            case .saveKYCInformation(let model):
                let userID = GMEDB.shared.user.string(.userId) ?? ""
                return [
                    "userId" : userID,
                    "type": model.type,
                    "fullName": model.personalInformation?.fullName ?? "",
                    "gender": model.personalInformation?.gender ?? "",
                    "dob": model.personalInformation?.dob ?? "",
                    "email": model.personalInformation?.email ?? "",
                    "city": model.personalInformation?.city ?? "",
                    "address": model.personalInformation?.address ?? "",
                    "occupation": model.personalInformation?.occupation ?? "",
                    "nativeCountry": model.personalInformation?.nativeCountry ?? "",
                    "bankId": model.primaryInformation?.bankID ?? "",
                    "bankAccount": model.primaryInformation?.bankAccount ?? "",
                    "passportNumber": model.primaryInformation?.passportNumber ?? "",
                    "passportIssueDate": model.primaryInformation?.passportIssueDate ?? "",
                    "passportExpiryDate": model.primaryInformation?.passportExpiryDate ?? "",
                    "anotherIDType": model.primaryInformation?.anotherIDType ?? "",
                    "anotherIDNumber": model.primaryInformation?.anotherIDNumber ?? "",
                    "anotherIDIssueDate": model.primaryInformation?.anotherIDIssueDate ?? "",
                    "anotherIDExpiryDate": model.primaryInformation?.anotherIDExpiryDate ?? "",
                    "branchId": model.primaryInformation?.branchID ?? "",
                    "refferalCode": model.primaryInformation?.refferalCode ?? ""
                ]
          */
            case .submitKYC(let model):
                return [
                    "type": model.type,
                    "purposeOfRegistration" : model.personalInformation?.purpose ?? "",
                    "employeerName": model.personalInformation?.employeerName ?? "",
                    "sourceOfFund": model.personalInformation?.sourceOfFund ?? "",
                    "monthlyIncome": model.personalInformation?.monthlyIncome ?? "",
                    "businessType": model.personalInformation?.businessType ?? "",
                    "mobile": model.personalInformation?.mobile ?? "",
                    "email": model.personalInformation?.email ?? "",
                    "additionalAddress": model.personalInformation?.address ?? "",
                    "idType": model.personalInformation?.idType ?? "",
                    "additionalIdType": model.personalInformation?.additionalIdType ?? "",
                    "userId": GMEDB.shared.user.string(.userId) ?? "",
                    "occupation": model.personalInformation?.occupation ?? ""
                ]
            
            case .submitExistingCustomerKYC(let model):
                return [
                    "type": model.type,
                    "purposeOfRegistration" : model.personalInformation?.purpose ?? "",
                    "employeerName": model.personalInformation?.employeerName ?? "",
                    "sourceOfFund": model.personalInformation?.sourceOfFund ?? "",
                    "monthlyIncome": model.personalInformation?.monthlyIncome ?? "",
                    "businessType": model.personalInformation?.businessType ?? "",
                    "mobile": model.personalInformation?.mobile ?? "",
                    "email": model.personalInformation?.email ?? "",
                    "additionalAddress": model.personalInformation?.address ?? "",
                    "idType": model.personalInformation?.idType ?? "",
                    "visaStatus": model.personalInformation?.additionalIdType ?? "",
                    "userId": GMEDB.shared.user.string(.userId) ?? "",
                    "occupation": model.personalInformation?.occupation ?? ""
                ]
                
            case .pennyTestSubmitAtRegister(let accountNumber, let certNumber):
                let senderID = GMEDB.shared.user.string(.senderId) ?? ""
                return [
                    "AccountNo": accountNumber,
                    "CertNumber": certNumber,
                    "CustomerId": senderID
                ]
                
            case .getNotifyInfo:
                let senderId = GMEDB.shared.user.string(.senderId) ?? ""
                return [
                    "customerId": senderId
                ]
                
            case .getNotifyDetailInfo(let idx):
                return [
                    "rowId": idx
                ]
                
            case .profileCheckPassword(let model, let target):
                let senderId = GMEDB.shared.user.string(.senderId) ?? ""
                return [
                    "userId": senderId,
                    "password": model.passwordForChangePersonalInformation ?? "",
                    "tempValue": model.newValue ?? "",
                    "targetInfo": target
                ]
                
            case .profileValidationOTP(let OTPPassword):
                let senderId = GMEDB.shared.user.string(.senderId) ?? ""
                return [
                    "userId": senderId,
                    "OTPNumber": OTPPassword
                ]
                
            case .profileChangeInformation(let newValue, let target):
                let senderId = GMEDB.shared.user.string(.senderId) ?? ""
                return [
                    "userId": senderId,
                    "newValue": newValue,
                    "targetInfo": target
                ]
                
            case .resendOTPForChangeProfileInformation(let newValue):
                let senderId = GMEDB.shared.user.string(.senderId) ?? ""
                return [
                    "userId" : senderId,
                    "tempValue" : newValue
                ]
                
            case .fetchPersonalInformation:
                let userId = GMEDB.shared.user.string(.senderId) ?? ""
                return [
                    "userId" : userId
                ]
                
            case .searchTxnByControlNumber(let controlNumber):
                return [
                    "userId" : GMEDB.shared.user.string(.userId) ?? "",
                    "controlNumber": controlNumber
                ]
                
            case .redeemCashPayment(let controlNumber, let txnId, let password):
                return [
                    "userId" : GMEDB.shared.user.string(.userId) ?? "",
                    "controlNumber": controlNumber,
                    "txnId": txnId,
                    "password": password
                ]
                
            case .withdrawWalletRequest(let amount):
                return [
                    "userId" : GMEDB.shared.user.string(.userId) ?? "",
                    "amount": amount
                ]
                
            case .withdrawFromWallet(let txnId, let amount, let password):
                return [
                    "userId" : GMEDB.shared.user.string(.userId) ?? "",
                    "amount": amount,
                    "txnId" : txnId,
                    "password" : password
                ]
                
            default: return nil
            }
            
        default : return nil
        }
    }
}