LONDON-IOS/GMERemittance/Social/SocialFeedViewModel.swift

//
//  SocialFeedsViewModel.swift
//  GMERemittance
//
//  Created by Sujal Manandhar
//  Copyright © 2018 Gobal Money Express Co. Ltd. All rights reserved.
//

import Foundation

class SocialFeedViewModel : ModelExtension {
    
    var particularFeed: SocialFeed!
    
    var socialFeedsRxValue:Box<Int?> = Box(nil)
    var imageUploaded:Box<Bool?> = Box(nil)
    var socialFeedConnectionTimeOut: Box<Bool?> = Box(nil)
    
    private var param = [String: String]()
    
    private var publicSocialFeedsArray = [SocialFeed]()
    private var privateSocialFeedsArray = [SocialFeed]()
    
    private var likedBy = [Like] ()
    private var commentedBy = [Comment] ()

    private let user_id =  UserDefaults.standard.object(forKey: "com.gmeremit.username") as! String
    
    private let num_feeds = 10
    private let num_comments = 10
    
    private let size_comments = 10
    private var page_comments: Int!
    
    private var feedBeforeId: String!
    private var feedAfterId: String!
    private var remainingFeeds: Int!
    
    private var commentBeforeId: String!
    private var commentAfterId: String!
    private var remainingComments: Int!
    
    private var feedImageId: String!
    private var feedText: String!
    private var accessType: String = "public"
    private var personal: Bool = false
    
    private var commentText: String!
 
    private var currentlyFetchedPublicFeedCount: Int = 0
    private var currentlyFetchedPrivateFeedCount: Int = 0
    
    private var currentlyFetchedCommentCount: Int = 0
}

extension SocialFeedViewModel {
    
    func resetBeforeId() {
        self.feedBeforeId = nil
    }
    
    //Set or Update the status post to share
    func updateFeedText(text: String) {
        self.feedText = text
    }
    
    //Set or Update the comment
    func updateCommentText(text: String) {
        self.commentText = text
    }
    
    //func setFeedImageId
    func setFeedImageId(imageId: String) {
        self.feedImageId = imageId
    }
    
    //Set accessType
    func setAccessType(accessType: String) {
        self.accessType = accessType
        
        switch accessType {
        case "private":
            personal = true
        case "public":
            personal = false
        default:
            return
        }
    }
    
    //Reset feed id
    func resetBeforeAfterFeedId() {
        feedBeforeId = nil
        feedAfterId = nil
    }
    
    /**
        For toggle action
     - parameter accesType: private or public
     */
    func getToggledAccessType(accessType: String) -> String {
        switch accessType {
        case "private":
            return "public"
        case "public":
            return "private"
        default:
            return ""
        }
    }
    
    /// - returns: count of array
    func getPublicSocialFeedsCount() -> Int {
        return publicSocialFeedsArray.count
    }
    
    /// - returns: count of array
    func getPrivateSocialFeedsCount() -> Int {
        return privateSocialFeedsArray.count
    }
    
    /**
     Get social feeds
     - returns: array of socail feed
    */
    func getSocialFeeds() -> [SocialFeed] {
        if personal {
            return privateSocialFeedsArray
        }
        return publicSocialFeedsArray
    }
    
    /**
     Get a social feed from array
     - parameter index: position of social feed in an array
     - returns: social feed
     */
    func getSocialFeedAt(index: Int) -> SocialFeed {
        if personal {
            return privateSocialFeedsArray[index]
        }
        return publicSocialFeedsArray[index]
    }
    
    /**
     Get a private social feed from array
     - parameter index: position of social feed in an array
     - returns: social feed
     */
    func getPrivateSocialFeedAt(index: Int) -> SocialFeed {
        return privateSocialFeedsArray[index]
    }
    
    /**
     Get a public social feed from array
     - parameter index: position of social feed in an array
     - returns: social feed
     */
    func getPublicSocialFeedAt(index: Int) -> SocialFeed {
        return publicSocialFeedsArray[index]
    }
    
    /**
     check image upload
     - returns: Bool
     */
    func imageFinishedUpload() -> Bool {
        if feedImageId == nil {
            return false
        }
        return true
    }
   
    /**
     Check user post
     - parameter PostIndex: position of a post in an array
     - returns: Bool
     */
    func postBelongsToMe(postIndex: Int) -> Bool {
        if personal {
            if privateSocialFeedsArray[postIndex].userId == user_id {
                return true
            }
            return false
        } else {
            if publicSocialFeedsArray[postIndex].userId == user_id {
                return true
            }
            return false
        }
    }
    
    /**
     Check private post
     - parameter postIndex: position of a post in an array
     - returns: Bool
     */
    func isPostPrivate(postIndex: Int) -> Bool {
        if privateSocialFeedsArray[postIndex].accessType == "private" {
            return true
        }
        return false
    }
    
    /**
     Check user comment
     - parameter commentIndex: position of a comment in an array
     - returns: Bool
     */
    func commentBelongsToMe(commentIndex: Int) -> Bool {
        if commentedBy[commentIndex].userId == user_id {
            return true
        }
        return false
    }
    
    /**
      - returns: array
     */
    func getAllLikes() -> [Like] {
        return likedBy
    }
    
    /**
     - returns: array
     */
    func getAllComments() -> [Comment] {
        return commentedBy
    }
    
    /**
     To get a comment
     - parameter index: position of a comment in an array
     - returns: Bool
     */
    func getCommentAt(index: Int) -> Comment {
        return commentedBy[index]
    }
    /**
     - returns: array count
     */
    func getCommentsCount() -> Int {
        return commentedBy.count
    }
    
    /**
     To update like count
     - parameter atIndex: position of a like in an array
     */
    func updateSocialFeedArrayLikeNumber(atIndex: Int) {
        var feedToUpdate = getSocialFeedAt(index: atIndex)
        if feedToUpdate.liked {
            feedToUpdate.totalLike = feedToUpdate.totalLike - 1
        } else {
            feedToUpdate.totalLike = feedToUpdate.totalLike + 1
        }
        feedToUpdate.liked = !feedToUpdate.liked
        updateFeedArray(atIndex: atIndex, withFeed: feedToUpdate)
    }
    
    /**
     To update comment count
     - parameter atIndex: position of a comment in an array
     - parameter increase: Bool
     */
    func updateSocialFeedArrayCommentNumber(atIndex: Int, increase: Bool) {
        var feedToUpdate = getSocialFeedAt(index: atIndex)
        if increase {
            feedToUpdate.totalComment  = feedToUpdate.totalComment + 1
        } else {
            feedToUpdate.totalComment = feedToUpdate.totalComment - 1
        }
        updateFeedArray(atIndex: atIndex, withFeed: feedToUpdate)
    }
    
    /**
     To update feed
     - parameter atIndex: position of a feed in an array
     - parameter withFeed: feed
     */
    func updateFeedArray(atIndex: Int, withFeed: SocialFeed) {
        if personal {
            privateSocialFeedsArray[atIndex] = withFeed
        } else {
            publicSocialFeedsArray[atIndex] = withFeed
        }
    }
 
    /**
        To get determine type of feed i.e private or public
     - parameter withFeed: feed
     */
    func toggleArrays(withFeed: SocialFeed) {
        
        let feedAccessType = withFeed.accessType
        
        if feedAccessType == "private" {
            //find the index of the feed in private array and update it with the updated feed
            if let index = privateSocialFeedsArray.index(where: {$0.id == withFeed.id}) {
                privateSocialFeedsArray.insert(withFeed, at: index)
            } else {
                privateSocialFeedsArray.insert(withFeed, at: 0)
            }
            
            
            //find the index of the feed in public array and remove it
            if let index2 = publicSocialFeedsArray.index(where: {$0.id == withFeed.id}) {
                publicSocialFeedsArray.remove(at: index2)
            }
            
        } else {
            //find the index of the feed in private array and update it with the updated feed
            let index = privateSocialFeedsArray.index(where: {$0.id == withFeed.id})
            privateSocialFeedsArray.insert(withFeed, at: index!)
            privateSocialFeedsArray.remove(at: index!+1)
            
            //insert the feed in public array
            publicSocialFeedsArray.insert(withFeed, at: 0)
        }
    }
    
    /**
     To update comment Array
     - parameter atIndex: position of a comment in an array
     - parameter increase: Comment
     */
    func updateCommentArray(atIndex: Int, withComment: Comment) {
       commentedBy[atIndex] = withComment
    }
    
    /**
     To remove social feed
     - parameter atIndex: position of a feed in an array
     */
    func removeSocialFeed(atIndex: Int) {
        if personal {
            privateSocialFeedsArray.remove(at: atIndex)
        } else {
            publicSocialFeedsArray.remove(at: atIndex)
        }
    }

    /**
     Remove all feeds
     */
    func clearFeedsArray() {
        if personal {
            privateSocialFeedsArray.removeAll()
        } else {
            publicSocialFeedsArray.removeAll()
        }
    }
    
    /**
     To remove a comment in an array
     - parameter atIndex: position of a feed in an array
     */
    func removeComment(atIndex: Int) {
        commentedBy.remove(at: atIndex)
    }
    
    /**
     Reset comment Aray
     */
    func resetCommentsArray() {
        commentedBy.removeAll()
        commentAfterId = nil
        commentBeforeId = nil
        remainingComments = 0
    }
    
    /**
     To get full name of a person who post in social feed
     - parameter feed: feed
     */
    func getFullName(feed: SocialFeed) -> String {
        if feed.middleName != nil {
            return feed.firstName + " " + feed.middleName! + " " + feed.lastName
        } else {
            return feed.firstName + " " + feed.lastName
        }
    }
    
    /**
     To load more the social feed list
     - returns: Bool
     */
    func loadMore() -> Bool {

        if remainingFeeds == nil || remainingFeeds == 0 {
            return false
        }
        return true
        
    }
   
    /// Reset feed count
    func resetFeedCount() {
        remainingFeeds = 0
    }
    
    /**
        To check comment status(remaining)
     - returns: Bool
     */
    func commentsRemaining() -> Bool {
        if remainingComments == nil || remainingComments == 0 {
            return false
        }
        return true
    }
    
    /**
        To get feed count
     - returns: count
     */
    func getCurrentlyFetchedFeedCount() -> Int {
        if personal {
            return currentlyFetchedPrivateFeedCount
        }
        return currentlyFetchedPublicFeedCount
    }
    
    /**
      To get comment count
     - returns count
     */
    func getCurrentlyFetchedCommentCount() -> Int {
        return currentlyFetchedCommentCount
    }
    
}

extension SocialFeedViewModel {
    
    //Upload User Image, successful upload gives image id
    func uploadImage(image: Any, isGif: Bool) {
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            self.imageUploaded.value = nil
            param = ["userId": user_id]
            feedImageId = nil
            RestApiMananger.sharedInstance.uploadImage(imageData: image, isGif: isGif, param: param, completion:  { (result) in
                switch result {
                case let .success(imageUploadJson):
                    self.feedImageId = imageUploadJson["id"].stringValue
                    self.imageUploaded.value = true
                case let .failure(errorJson):
                    self.setErrorMessage(message: errorJson["message"].stringValue)
                    self.imageUploaded.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.uploadImage(image: image, isGif: isGif)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                    
                case .timeOut:
                     self.socialFeedConnectionTimeOut.value = false
                }
            })
        }
    }
    
    //CREATE Social Feeds
    func createSocialFeed() {
        
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            
            let areParamsAvailable = feedText != nil || feedImageId != nil
            
            guard areParamsAvailable else {
                self.setErrorMessage(message: "No content available")
                self.socialFeedsRxValue.value = 0
                return
            }
            
            param.removeAll()
            param = ["userId": user_id, "accessType": accessType]
            
            if feedText != nil {
                if !feedText.isBlank {
                    param["feedText"] = feedText
                }
            }
            
            if feedImageId != nil {
                param["feedImageId"] = feedImageId
            }
            
            
            RestApiMananger.sharedInstance.createSocialFeed(param: param, completion: { (result) in
                switch result {
                case let .success(createdFeedJSON):
                    do {
                        let createdFeed = try JSONDecoder().decode(SocialFeed.self, from: createdFeedJSON.rawData())
                        if self.personal {
                            self.privateSocialFeedsArray.insert(createdFeed, at: 0)
                        } else {
                            self.publicSocialFeedsArray.insert(createdFeed, at: 0)
                            self.privateSocialFeedsArray.insert(createdFeed, at: 0)
                        }
                        
                        self.feedText = nil
                        self.feedImageId = nil
                        
                        self.socialFeedsRxValue.value = 3
                    } catch {
                       
                        self.socialFeedsRxValue.value = 0
                    }
             
                case let .failure(errorJson):
                    self.setErrorMessage(message: errorJson["message"].stringValue)
                    self.socialFeedsRxValue.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.createSocialFeed()
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                     self.socialFeedConnectionTimeOut.value = false
                }
            })
        }
    }
    
    //READ social feeds from server
    func fetchSocialFeeds(isPublic: Bool, loadMore: Bool) {
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            
            param.removeAll()
            
            if loadMore {
                if feedAfterId != nil {
                    param["after"] = feedAfterId
                }
            } else {
                if feedBeforeId != nil {
                    param["before"] = feedBeforeId
                }
            }

            
            param["userId"] = user_id
            param["personal"] = String(personal)
            param["limit"] = String(num_feeds)
            
            
            RestApiMananger.sharedInstance.getSocialFeeds(param: param, completion: { (result) in
                
                print("Param = ", self.param)
                switch result {
                
                case let .success(feedsResponseJson):

                    if self.feedBeforeId == nil && self.feedAfterId == nil {
                        self.clearFeedsArray()
                    }
                    
                    if feedsResponseJson.count == 2 {
                        let feedsJson = feedsResponseJson["objects"]
                        
                        for feed in feedsJson {
                            do {
                                let socialFeed = try JSONDecoder().decode(SocialFeed.self, from: feed.1.rawData())
                                if isPublic {
                                    
                                    self.publicSocialFeedsArray.append(socialFeed)
                                } else {
                                    
                                    self.privateSocialFeedsArray.append(socialFeed)
                                }
                            } catch let err {
                                
                                self.setErrorMessage(message: "Error Decoding" + err.localizedDescription)
                                self.socialFeedsRxValue.value = 0
                                return
                            }
                        }
                        
                        let paginationJson = feedsResponseJson["pageInformation"]
                        
                        if let before = paginationJson["before"].rawString() {
                            //Since backend returns string 'null', so it interferes with future call with beforeId being set as 'null' so added if clause to prevent this case
                            if before != "null" {
                                self.feedBeforeId = before
                            }
                        }
                        if let after = paginationJson["after"].rawString() {
                            self.feedAfterId = after
                        }
                       
                        self.remainingFeeds = paginationJson["remaining"].intValue
                            if isPublic {
                                self.currentlyFetchedPublicFeedCount = feedsJson.count
                                self.socialFeedsRxValue.value = 1
                            } else {
                                self.currentlyFetchedPrivateFeedCount = feedsJson.count
                                self.socialFeedsRxValue.value = 11
                            }
                     
                    } else {
                        self.setErrorMessage(message: "Data format not matched!")
                        self.socialFeedsRxValue.value = 0
                    }
                   
                case let .failure(errorJson):
                    self.setErrorMessage(message: "Social" + errorJson["message"].stringValue)
                    self.socialFeedsRxValue.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.fetchSocialFeeds(isPublic: isPublic, loadMore: loadMore)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.socialFeedConnectionTimeOut.value = false
                }
            })
        }
    }
    
    //UPDATE Social Feeds
    func updateSocialFeed(feed: SocialFeed, index: Int, toggle: Bool = false) {
        
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            
            param.removeAll()
            
            if toggle {
                param = ["userId": user_id, "accessType": getToggledAccessType(accessType: feed.accessType)]
                
                if feed.feedText != nil {
                    param["feedText"] = feedText //feed.feedText
                }
                
                if feed.feedImageId != nil {
                    param["feedImageId"] = feedImageId //feed.feedImageId
                }
                
            } else {
                param = ["userId": user_id, "accessType": feed.accessType]
                
 
                let areParamsAvailable = (feedText != nil && feedText != "") || feedImageId != nil
                
                guard areParamsAvailable else {
                    self.setErrorMessage(message: "No update parameters found")
                    self.socialFeedsRxValue.value = 0
                    return
                }
                
                if feedText != nil {
                    if !feedText.isBlank {
                        param["feedText"] = feedText
                    }
                }
                
                if feedImageId != nil {
                    param["feedImageId"] = feedImageId
                }
                
            }
            
          
            RestApiMananger.sharedInstance.updateSocialFeed(feedId: feed.id, param: param, completion: { (result) in
                switch result {
                case let .success(updatedFeedJson):
                    DispatchQueue.main.asyncAfter(deadline: .now() + 7) { // change 2 to desired number of seconds
                        // Your code with delay
                    
                    do {
                        let updatedFeed = try JSONDecoder().decode(SocialFeed.self, from: updatedFeedJson.rawData())
                        if !toggle {
                            self.updateFeedArray(atIndex: index, withFeed: updatedFeed)
                        } else {
                            self.toggleArrays(withFeed: updatedFeed)
                        }
                        
                        self.feedText = nil
                        self.feedImageId = nil
                        
                        self.socialFeedsRxValue.value = 3
                    } catch {
                        self.setErrorMessage(message: "Unable to parse feed")
                        self.socialFeedsRxValue.value = 0
                        }}
                case let .failure(errorJson):
                    self.setErrorMessage(message: errorJson["message"].stringValue)
                    self.socialFeedsRxValue.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.updateSocialFeed(feed: feed, index: index)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.socialFeedConnectionTimeOut.value = false
                }
            })
        }
    }
    
    //DELETE Social Feeds
    func deleteSocialFeed(feedId: String) {
        
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
             param = ["userId": user_id]
            RestApiMananger.sharedInstance.deleteSocialFeed(feedId: feedId, param: param, completion: { (result) in
                switch result {
                case .success(_):
                    self.socialFeedsRxValue.value = 2
                    
                case let .failure(errorJson):
                    self.setErrorMessage(message: errorJson["message"].stringValue)
                    self.socialFeedsRxValue.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.deleteSocialFeed(feedId: feedId)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.socialFeedConnectionTimeOut.value = false
                }
            })
        }
    }
    
    //DELETE Social Feeds
    func reportSocialFeed(feedId: String, reportMessage: String) {
        
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            param = ["userId": user_id, "reportMessage": reportMessage]
            RestApiMananger.sharedInstance.reportSocialFeed(feedId: feedId, param: param, completion: { (result) in
                switch result {
                case .success(_):
                    self.socialFeedsRxValue.value = socialWallCode.reportPost.rawValue
                    
                case let .failure(errorJson):
                    self.setErrorMessage(message: errorJson["message"].stringValue)
                    self.socialFeedsRxValue.value = socialWallCode.error.rawValue
                    
                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.deleteSocialFeed(feedId: feedId)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.socialFeedConnectionTimeOut.value = false
                }
            })
        }
    }
    
    //LIKE UNLIKE Feed
    func likeDislikePost(feedId: String, liked: Bool) {
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            param = ["userId": user_id]
            RestApiMananger.sharedInstance.likeDislikeSocialFeed(feedId: feedId, isLiked: liked, param: param, completion: { (result) in
                switch result {
                case .success(_):
                    self.socialFeedsRxValue.value = 4
                    
                case let .failure(errorJson):
                    self.setErrorMessage(message: errorJson["message"].stringValue)
                    self.socialFeedsRxValue.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.deleteSocialFeed(feedId: feedId)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.socialFeedConnectionTimeOut.value = false
                }
            })
        }
    }
    
    // LIKES for a feed
    func fetchAllLikesFor(feedId: String) {
        

        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            RestApiMananger.sharedInstance.getAllLikesFor(feedId: feedId, completion: { (result) in
                
                switch result {
                case let .success(likedJSON):
                    self.likedBy.removeAll()
                    
                    guard likedJSON.count > 0 else {
                        self.setErrorMessage(message: "No likes fetched")
                        self.socialFeedsRxValue.value = 0
                        return
                    }
                    
                    for i in 0 ... (likedJSON.count-1) {
                        do {
                            let like = try JSONDecoder().decode(Like.self, from: likedJSON[i].rawData())
                            
                            self.likedBy.append(like)
                        } catch {
                          
                        }
                    }
                    self.socialFeedsRxValue.value = 5
                    
                case let .failure(errorJson):
                    self.setErrorMessage(message: errorJson["message"].stringValue)
                    self.socialFeedsRxValue.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.fetchAllLikesFor(feedId: feedId)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.socialFeedConnectionTimeOut.value = false
                }
            })
        }
    }
    
    //GET COMMMENTS FOR A FEED
    func fetchAllCommentsFor(feedId: String, loadMore: Bool) {
        
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            param.removeAll()
            
            if loadMore {
                if commentAfterId != nil {
                    param["after"] = commentAfterId
                }
            } else {
                if commentBeforeId != nil {
                    param["before"] = commentBeforeId
                }
            }
            
            param["limit"] = String(num_comments)
            
            
            RestApiMananger.sharedInstance.getAllCommentsFor(feedId: feedId, param: param, completion: { (result) in
                
                switch result {
                case let .success(commentsResponseJSON):
                    
                    guard commentsResponseJSON.count > 0 else {
                        self.socialFeedsRxValue.value = nil
                        return
                    }
                    
                    if commentsResponseJSON.count == 2 {
                        
                        self.currentlyFetchedCommentCount = 0
                        
                        let commentsJSON = commentsResponseJSON["objects"]
                        for comment in commentsJSON {
                        
                            do {
                                let comment = try JSONDecoder().decode(Comment.self, from: comment.1.rawData())
                                
                                self.commentedBy.append(comment)
                            } catch {
                                self.setErrorMessage(message: "Error Decoding Comment")
                                self.socialFeedsRxValue.value = 0
                            }
                        }
                    
                        let paginationJson = commentsResponseJSON["pageInformation"]
                        
                        if let before = paginationJson["before"].rawString() {
                            self.commentBeforeId = before
                        }
                        if let after = paginationJson["after"].rawString() {
                            self.commentAfterId = after
                        }
                        self.remainingComments = paginationJson["remaining"].intValue
                        
                        self.currentlyFetchedCommentCount = commentsJSON.count
                        self.socialFeedsRxValue.value = 6
                    } else {
                        self.setErrorMessage(message: "Data format not matched!")
                        self.socialFeedsRxValue.value = 0
                    }
                    
                case let .failure(errorJson):
                    self.setErrorMessage(message: errorJson["message"].stringValue)
                    self.socialFeedsRxValue.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.fetchAllCommentsFor(feedId: feedId, loadMore: loadMore)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.socialFeedConnectionTimeOut.value = false
                }
            })
        }
    }
    
    //DELETE COMMENT
    func removeComment(feedId: String, commentId: String) {
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            
            let param = ["userId": user_id]
            
            RestApiMananger.sharedInstance.deleteComment(feedId: feedId, commentId: commentId, param: param, completion: { (result) in
                switch result {
                case .success(_):
                    self.socialFeedsRxValue.value = 8
                    
                case let .failure(errorJson):
                    self.setErrorMessage(message: errorJson["message"].stringValue)
                    self.socialFeedsRxValue.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.deleteSocialFeed(feedId: feedId)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.socialFeedConnectionTimeOut.value = false
                }
            })
        }
    }
    
    //CREATE comment
    func createCommentFor(feedId: String) {
        
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {

            guard commentText != nil, commentText != "", !commentText.isBlank else {
                self.setErrorMessage(message: "Empty comment")
                self.socialFeedsRxValue.value = 0
                return
            }
            param.removeAll()
            param["userId"] = user_id
            param["comment"] = commentText
            
            RestApiMananger.sharedInstance.createComment(feedId: feedId, param: param, completion: { (result) in
                switch result {
                case let .success(createdCommentJSON):
                    do {
                        let createdComment = try JSONDecoder().decode(Comment.self, from: createdCommentJSON.rawData())
                        
                        self.commentedBy.insert(createdComment, at: 0)
                        
                        self.commentText = nil
                        
                        self.socialFeedsRxValue.value = 7
                    } catch {
                        self.setErrorMessage(message: "Unable to parse feed")
                        self.socialFeedsRxValue.value = 0
                    }
                    
                case let .failure(errorJson):
                    self.setErrorMessage(message: errorJson["message"].stringValue)
                    self.socialFeedsRxValue.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.createCommentFor(feedId: feedId)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.socialFeedConnectionTimeOut.value = false
                }
            })
        }
    }

    //UPDATE comment
    func updateCommentFor(feedId: String, commentId: String, commentIndex: Int) {
        
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            
            guard commentText != nil, commentText != "", !commentText.isBlank else {
                self.setErrorMessage(message: "Empty comment")
                self.socialFeedsRxValue.value = 0
                return
            }
            param.removeAll()
            param["userId"] = user_id
            param["comment"] = commentText
            
            RestApiMananger.sharedInstance.editComment(feedId: feedId, commentId: commentId, param: param,  completion: { (result) in
                switch result {
                case let .success(editedCommentJSON):
                    do {
                        let editedComment = try JSONDecoder().decode(Comment.self, from: editedCommentJSON.rawData())
                      
                        self.updateCommentArray(atIndex: commentIndex, withComment: editedComment)
                        
                        self.commentText = nil
                        self.socialFeedsRxValue.value = 7
                    } catch {
                        self.setErrorMessage(message: "Unable to parse feed")
                        self.socialFeedsRxValue.value = 0
                    }
                    
                case let .failure(errorJson):
                    self.setErrorMessage(message: errorJson["message"].stringValue)
                    self.socialFeedsRxValue.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.updateCommentFor(feedId: feedId, commentId: commentId, commentIndex: commentIndex)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                    self.socialFeedConnectionTimeOut.value = false
                }
            })
        }
    }
    
    /**
     To get feed with id
     - parameter feedId: feedId
     */
    func fetchFeedWithId(feedId: String) {
        
        if !Reachability.isConnectedToNetwork() {
            self.internetConnection.value = false
        } else {
            param.removeAll()
            param = ["userId": user_id]
            RestApiMananger.sharedInstance.getParticularSocialFeed(feedId: feedId, param: param,  completion: { (result) in
                switch result {
                case let .success(feedJSON):
                    do {
                        self.particularFeed = try JSONDecoder().decode(SocialFeed.self, from: feedJSON.rawData())
                        
                        self.socialFeedsRxValue.value = 10
                    } catch {
                        self.setErrorMessage(message: "Unable to parse feed")
                        self.socialFeedsRxValue.value = 0
                    }
                    
                case let .failure(errorJson):
                    self.setErrorMessage(message: errorJson["message"].stringValue)
                    self.socialFeedsRxValue.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.fetchFeedWithId(feedId: feedId)
                        }
                    }
                case .logOutUser():
                    RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
                    self.anotherLogin.value = true
                case .timeOut:
                   self.socialFeedConnectionTimeOut.value = false
                }
            })
        }
    }
    
    /**
     - returns: social feed
     */
    func getParticularFeed() -> SocialFeed {
        return particularFeed
    }
    
    /**
     To update feed with like number
     */
    func updateParticularFeedWithUpdatedLikeNumber() {
        if particularFeed.liked {
            particularFeed.totalLike = particularFeed.totalLike - 1
        } else {
            particularFeed.totalLike = particularFeed.totalLike + 1
        }
        particularFeed.liked = !particularFeed.liked
    }
    
    /**
     To update feed with increase comment number
     */
    func updateParticularFeedWithIncreasedCommentNumber() {
        particularFeed.totalComment = particularFeed.totalComment + 1
    }
    
    /**
     To update feed with  decrease comment number
     */
    func updateParticularFeedWithDecreasedCommentNumber() {
        particularFeed.totalComment = particularFeed.totalComment - 1
    }
    
    /**
     To get feed belongs to user
     */
    func particularPostBelongsToMe() -> Bool {
        if particularFeed.userId == user_id {
            return true
        }
        return false
    }
}