LONDON-IOS/GMERemittance/Reward/RewardViewModel.swift

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

import Foundation

class RewardViewModel: ModelExtension {
    
    var rewardsAvailable: Box<Int?> = Box(nil)
    
    private var rewards: [Reward] = [Reward] ()
    
    private var rewardNames: [String] = [String] ()
    private var rewardImageNames: [String] = [String] ()
    private var rewardRedeemPoints: [Int] = [Int] ()
    private var selectedRewardIndex: Int!
    private var address: String!
    
    var rewardConnectionTimeOut: Box<Bool?> = Box(nil)
   
    private let user_id =  UserDefaults.standard.object(forKey: "com.gmeremit.username") as! String
}

extension RewardViewModel {
    
    /**
     - returns: reward list
     */
    func getRewards() -> [Reward] {
        return rewards
    }
    
    /**
     - returns: rewards count
     */
    func getRewardCount() -> Int {
        return rewards.count
    }
    
    /**
     To get reward id
     - parameter index: position of reward id in an array
     - returns: reward id
     */
    func getRewardId(index: Int) -> String {
        return rewards[index].rewardId
    }
    
    /**
     To get reward name
     - parameter index: position of reward name in an array
     - returns: name
     */
    func getRewardName(index: Int) -> String {
        return rewards[index].rewardName
    }
    
    /**
     To get reward image url
     - parameter index: position of reward image url in an array
     - returns: url
     */
    func getRewardImage(index: Int) -> String? {
        if let rewardUrl = rewards[index].rewardUrl {
            return rewardUrl
        }
        return nil
    }
    
    /**
     To get redeem point
     - parameter index: position of redeem point in an array
     - returns: point
     */
    func getRedeemPoint(index: Int) -> String {
        return rewards[index].redeemPoints
    }
    
    /**
     To get selected reward
     - parameter index: position of selected reward
     - returns: index
     */
    func getSelectedRewardIndex() -> Int {
        return selectedRewardIndex
    }
    
    /**
     To set selected reward
     - parameter index: position of selected reward
     */
    func setSelectedRewardIndex(index: Int) {
        selectedRewardIndex = index
    }
    
}

extension RewardViewModel {
    
    /**
        Validate the empty textfield
     */
    func validateAddress(address: String) -> isValid {
        self.address = address.removeSpacesTrailingPreceding()
        if address.isBlank {
            return .InValid("Please fill the address")
        }
        return .Valid
    }
    
    func submitRequest() {
        
    }
}

extension RewardViewModel {

    /**
        Api request for reward
     */
    func fetchRewards() {
        
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
           
            RestApiMananger.sharedInstance.fetchRewards(completion:  { (result) in
                switch result {
                    
                case let .success(rewardsJson):
                    
                    guard rewardsJson.count > 0 else {
                        self.setErrorMessage(message: "No rewards obtained")
                        self.rewardsAvailable.value = 0
                        return
                    }
                    
                    self.rewards.removeAll()
                    
                    for i in 0 ... (rewardsJson.count-1) {
                        do {
                            let reward = try JSONDecoder().decode(Reward.self, from: rewardsJson[i].rawData())
                            
                            self.rewards.append(reward)
                            
                        } catch let err {
                            self.setErrorMessage(message: "Error Decoding: " + String(describing: err))
                            self.rewardsAvailable.value = 0
                        }
                    }
                    self.rewardsAvailable.value = 1
                    
                case  .failure(_):
                    self.setErrorMessage(message: "Error Fetching Rewards")
                    self.rewardsAvailable.value = 0
                
                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.fetchRewards()
                        }
                    }
                  
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.rewardConnectionTimeOut.value = false
                }
            })
        }
    }
    
    
    /**
        Api request for redeem requst
     - parameter rewardId: add to reward id
     */
    func redeemReward(rewardId: String) {
        
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            
            let param: [String: String] = ["userId": user_id, "userAddress": address]
            
            RestApiMananger.sharedInstance.redeemReward(rewardId: rewardId, param: param, completion:  { (result) in
                switch result {
                    
                case let .success(redeemedJson):
                    UserDefaults.standard.set(redeemedJson["remainingRedeemPoints"].stringValue, forKey: "com.gmeremit.rewardPoint")
                    self.rewardsAvailable.value = 2
                    
                   
                case  .failure(_):
                    self.setErrorMessage(message: "Error Redeeming Rewards")
                    self.rewardsAvailable.value = 0
                    
                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.redeemReward(rewardId: rewardId)
                        }
                    }
                    
                case .logOutUser():
                    self.anotherLogin.value = true
                case .timeOut:
                    self.rewardConnectionTimeOut.value = false
                }
            })
        }
    }
}