//
//  UserInfoViewModel.swift
//  GMERemittance
//
//  Created by FMI-12 on 1/30/18.
//  Copyright © 2018 Gobal Money Express Co. Ltd. All rights reserved.
//

import Foundation

class UserInfoViewModel: ModelExtension {
    
    var userDataAvailable:Box<Bool?> = Box(nil)
    var userOccupationProvinceAvailable:Box<Int?> = Box(nil) // -1 = handle keypad when user is auto logout, 0 = Error, 5 = Occupation, 3 = Province
    var userSourceFundAvailable:Box<Bool?> = Box(nil)
    var userConnectionTimeOut: Box<Bool?> = Box(nil)
    
    
    private var cddOccupationList: [String] = [String] ()
    private var cddOccupationValueList: [String] = [String] ()
    
    private var cddSourceFundList: [String] = [String] ()
    private var cddSourceFundValueList: [String] = [String] ()
    
    private var cddProvinceList: [String] = [String] ()
    private var cddProvinceValueList: [String] = [String] ()
    
    private var userInfo = KYCModel()

    let user_id = UserDefaults.standard.object(forKey: "com.gmeremit.username") as? String

    /**
        APi request for user information
     */
    func fetchUserInfo() {
        if !Reachability.isConnectedToNetwork() {
           self.internetConnection.value = false
        } else {
            RestApiMananger.sharedInstance.fetchUserInfoFromKyc(userId: user_id!) { result in
                switch result {
                case let .success(fetchedJSON):
                    guard fetchedJSON.count > 0 else {
                        self.userDataAvailable.value = false
                        return
                    }
                    
                    do {
                        self.userInfo = try JSONDecoder().decode(KYCModel.self, from: fetchedJSON.rawData())
                        
                        self.userDataAvailable.value = true
                        
                    } catch  {
                        
                        self.userDataAvailable.value = false
                    }
                case let .failure(errorJSON):
                    self.setErrorMessage(message: errorJSON["message"].stringValue)
                    self.userDataAvailable.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.fetchUserInfo()
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.userConnectionTimeOut.value = false
                }
            }
        }
    }
    
    /**
        APi Request to update userINfo
     - parameter param: user info in Dictionary
     */
    func updateUserInfo(param: [String: String]) {
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            
            RestApiMananger.sharedInstance.updateUserInfoForKyc(userId: getUserId(), parameter: param) { result in
                switch result {
                case .success(_):
                    self.userDataAvailable.value = true
                    self.userDataAvailable.value = nil
                case let .failure(errorJSON):
                    self.setErrorMessage(message: errorJSON["message"].stringValue)
                    self.userDataAvailable.value = false
                    self.userDataAvailable.value = nil
                    
                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.updateUserInfo(param: param)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.userConnectionTimeOut.value = false
                }
            }
        }
        
    }
    
    /**
        Api request for CddList value
     - parameter cddName: Type of cddName
     - parameter param: [:]
     */
    func fetchCDDList(cddName: String, param: [String: String]?) {
        let cdd_name = cddName
        if !Reachability.isConnectedToNetwork() {
           self.internetConnection.value = false
        } else {
            RestApiMananger.sharedInstance.getCDDListFor(cddCode: cddName, param: param) { result in
                switch result {
                case let .success(cddJSON):
                    switch cddName {
                    case cddCode.Occupation.rawValue:
                        self.cddOccupationList.removeAll()
                        self.cddOccupationValueList.removeAll()
                    case cddCode.SourceFund.rawValue:
                        self.cddSourceFundList.removeAll()
                        self.cddSourceFundValueList.removeAll()
                    case cddCode.Province.rawValue:
                        self.cddProvinceList.removeAll()
                        self.cddProvinceValueList.removeAll()
                    default:
                        return
                    }
                    
                    if cddJSON.count > 0 {
                        for i in 0 ... (cddJSON.count-1) {
                            do {
                                let cddNameValuePair = try JSONDecoder().decode(Cdd.self, from: cddJSON[i].rawData())
                                switch cddName {
                                case cddCode.Occupation.rawValue:
                                    self.cddOccupationList.append(cddNameValuePair.name)
                                    self.cddOccupationValueList.append(cddNameValuePair.value)
                                case cddCode.SourceFund.rawValue:
                                    self.cddSourceFundList.append(cddNameValuePair.name)
                                    self.cddSourceFundValueList.append(cddNameValuePair.value)
                                case cddCode.Province.rawValue:
                                    self.cddProvinceList.append(cddNameValuePair.name)
                                    self.cddProvinceValueList.append(cddNameValuePair.value)
                                    
                                default:
                                    return
                                }
                            } catch {
                                switch cddName {
                                case cddCode.Occupation.rawValue:
                                    self.userOccupationProvinceAvailable.value = 0
                                case cddCode.SourceFund.rawValue:
                                    self.userSourceFundAvailable.value = false
                                default:
                                    return
                                }
                                break
                            }
                        }
                    }
                    switch cddName {
                    case cddCode.Occupation.rawValue:
                        self.userOccupationProvinceAvailable.value = 5
                    case cddCode.Province.rawValue:
                        self.userOccupationProvinceAvailable.value = 3
                    case cddCode.SourceFund.rawValue:
                        self.userSourceFundAvailable.value = true
                    default:
                        return
                    }
                    
                case .failure(_):
                    switch cddName {
                    case cddCode.Occupation.rawValue:
                        self.userOccupationProvinceAvailable.value = 0
                    case cddCode.SourceFund.rawValue:
                        self.userSourceFundAvailable.value = false
                    default:
                        return
                    }
                    
                    return
                    
                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.fetchCDDList(cddName: cdd_name, param: param)
                        }
                    }
                case .logOutUser():
                    self.userOccupationProvinceAvailable.value = -1
                    self.userSourceFundAvailable.value = nil
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.userConnectionTimeOut.value = false
                }
                
            }
        }
    }
    
    /**
        To get occupation List
     - returns: occupation list
     */
    func getOccupationList() -> [String] {
        return cddOccupationList
    }
    
    /**
     - parameter index: position of occupation in an array
     - returns: occupation
     */

    func getOccupationID(index: Int) -> String {
        return cddOccupationValueList[index]
    }
    
    /**
     To get province List
     - returns: privince list
     */
    func getProvinceList() -> [String] {
        return cddProvinceList
    }
    
    /**
     - parameter index: position of province in an array
     - returns: province
     */

    func getProvinceID(index: Int) -> String {
        return cddProvinceValueList[index]
    }
    
    /**
     To get source fund List
     - returns: source fund list
     */
    func getSourceFundList() -> [String] {
        return cddSourceFundList
    }
    
    /**
     - parameter index: position of source fund in an array
     - returns: source fund
     */

    func getSourceFundID(index: Int) -> String {
        return cddSourceFundValueList[index]
    }
    
    /**
     To get user info
     - returns: user info
     */
    func getInfo() -> KYCModel {
        return userInfo
    }
    
    /**
     To get address
     - returns: address
     */
    func getAddress() -> String {
        return ""// userInfo.address + ", " + userInfo.city
    }
    
    /**
     To get data array
     - returns: empty array
     */
    func getEmptyData() -> [String] {
        return [String]()
    }
}