import Foundation
import MapmyIndiaAPIKit
import MapmyIndiaDirections
import MapmyIndiaGeoanalytics


@objc(MGLRestApiModule)
class MGLRestApiModule : NSObject {
    
    let REQUIRED_CODE = "REQUIRED PARAMETER";
    
    @objc static func requiresMainQueueSetup() -> Bool {
          return true
      }
    
    //exporting constants
    @objc func constantsToExport() -> NSObject {
        let autosuggestConstants:NSDictionary = [
            "POD_CITY": MMIPodTypeIdentifier.city,
            "POD_DISTRICT": MMIPodTypeIdentifier.district,
            "POD_LOCALITY":MMIPodTypeIdentifier.locality,
            "POD_STATE": MMIPodTypeIdentifier.state,
            "POD_SUB_DISTRICT": MMIPodTypeIdentifier.subdistrict,
            "POD_SUB_LOCALITY": MMIPodTypeIdentifier.sublocality,
            "POD_SUB_SUB_LOCALITY": MMIPodTypeIdentifier.subSubLocality,
            "POD_VILLAGE": MMIPodTypeIdentifier.village,
            ];
        
        let geoCodeConstants:NSDictionary = [
                //Not avaialble for IOS
        //        @"BIAS_DEFAULT": MMIPodTypeIdentifierCity,
        //        @"BIAS_RURAL": MMIPodTypeIdentifierDistrict,
        //        @"BIAS_URBAN":MMIPodTypeIdentifierLocality,
        
                "POD_CITY": MMIPodTypeIdentifier.city,
                "POD_DISTRICT": MMIPodTypeIdentifier.district,
                //"POD_HOUSE_NAME": MMIPodTypeIdentifier.city,
                //"POD_HOUSE_NUMBER":MMIPodTypeIdentifier.city,
                "POD_LOCALITY": MMIPodTypeIdentifier.locality,
                //"POD_PINCODE": MMIPodTypeIdentifier.city,
                //"POD_POINT_OF_INTEREST": MMIPodTypeIdentifier.pointOfInterest,
                "POD_STATE": MMIPodTypeIdentifier.state,
                //"POD_STREET": MMIPodTypeIdentifier.city,
                "POD_SUB_DISTRICT": MMIPodTypeIdentifier.subdistrict,
                "POD_SUB_LOCALITY": MMIPodTypeIdentifier.sublocality,
                "POD_SUB_SUB_LOCALITY": MMIPodTypeIdentifier.subSubLocality,
                "POD_VILLAGE": MMIPodTypeIdentifier.village,
            ];
        
        let  nearbyConstants:NSDictionary = [
            "DISTANCE_ASCENDING":MapmyIndiaSortByDistanceWithOrder(orderBy: .ascending), //MMISortByOrderType.ascending,
            "DISTANCE_DESCENDING":MapmyIndiaSortByDistanceWithOrder(orderBy: .descending), //MMISortByOrderType.descending,
        
                //TODO: NEED TO CHECK
                "NAME_ASCENDING":MMISortByOrderType.ascending,
                "NAME_DESCENDING": MMISortByOrderType.descending,
        
            "DISTANCE": MMISearchByType.distance,
            "IMPORTANCE": MMISearchByType.importance,
        
            ];
        
        let directionConstants:NSDictionary = [
                //TODO: NEED TO CHECK
//                 "EXCLUDE_TUNNEL": MapmyIndiaDirections.ExcludeOptions.toll,
//                 "EXCLUDE_RESTRICTED": MapmyIndiaDirections.ExcludeOptions.toll,
                 "EXCLUDE_MOTORWAY":MapmyIndiaDirections.ExcludeOptions.motorway,
                 "EXCLUDE_FERRY": MapmyIndiaDirections.ExcludeOptions.ferry,
                 "EXCLUDE_TOLL": MapmyIndiaDirections.ExcludeOptions.toll,
        
                //TODO: NEED TO CHECK
//                @"ANNOTATION_SPEED": MMIPodTypeIdentifierSublocality,
//                @"ANNOTATION_NODES": MMIPodTypeIdentifierSubSubLocality,
//                @"ANNOTATION_MAXSPEED": MMIPodTypeIdentifierVillage,
//                @"ANNOTATION_DURATION": MMIPodTypeIdentifierVillage,
//                @"ANNOTATION_DISTANCE": MMIPodTypeIdentifierVillage,
//                @"ANNOTATION_BASE_DURATION": MMIPodTypeIdentifierVillage,
//                @"ANNOTATION_CONGESTION": MMIPodTypeIdentifierVillage,
//                @"ANNOTATION_SPEED_LIMIT": MMIPodTypeIdentifierVillage,
        
        
                 "OVERVIEW_FALSE": RouteShapeResolution.none.description,
                 "OVERVIEW_SIMPLIFIED":RouteShapeResolution.low.description,
                 "OVERVIEW_FULL": RouteShapeResolution.full.description,
        
        
                "PROFILE_WALKING": MapmyIndiaDirectionsProfileIdentifier.walking,
                "PROFILE_TRUCKING": MapmyIndiaDirectionsProfileIdentifier.trucking,
                "PROFILE_BIKING": MapmyIndiaDirectionsProfileIdentifier.biking,
                "PROFILE_DRIVING": MapmyIndiaDirectionsProfileIdentifier.driving,
        
        
                "RESOURCE_ROUTE_TRAFFIC": MBDirectionsResourceIdentifier.routeTraffic,
                "RESOURCE_ROUTE": MBDirectionsResourceIdentifier.routeAdv,
                "RESOURCE_ROUTE_ETA": MBDirectionsResourceIdentifier.routeETA,
                "RESOURCE_DISTANCE": MapmyIndiaDistanceMatrixResourceIdentifier.default,
                "RESOURCE_DISTANCE_ETA": MapmyIndiaDistanceMatrixResourceIdentifier.eta,
                "RESOURCE_DISTANCE_TRAFFIC": MapmyIndiaDistanceMatrixResourceIdentifier.traffic,
        
        
                 "GEOMETRY_POLYLINE": RouteShapeFormat.polyline.description,
                 "GEOMETRY_POLYLINE6": RouteShapeFormat.polyline6.description,
        
        
                 "IMPERIAL": MeasurementSystem.imperial.description,
                 "METRIC": MeasurementSystem.metric.description,
        
                //TODO: NEED TO CHECK
//                @"SOURCE_ANY": MMIPodTypeIdentifierVillage,
//                @"SOURCE_FIRST": MMIPodTypeIdentifierVillage,
        
                //TODO: NEED TO CHECK
//                @"APPROACH_CURB": MMIPodTypeIdentifierVillage,
//                @"APPROACH_UNRESTRICTED": MMIPodTypeIdentifierVillage,
        
                //TODO: NEED TO CHECK
//                @"DESTINATION_ANY": MMIPodTypeIdentifierVillage,
//                @"DESTINATION_LAST": MMIPodTypeIdentifierVillage,
            ];
        
        let poiConstants:NSDictionary = [
            "GEOMETRY_BASE64": MMIPolylineGeometryType.base64,
            "GEOMETRY_POLYLINE5": MMIPolylineGeometryType.polyline5,
            "GEOMETRY_POLYLINE6": MMIPolylineGeometryType.polyline6,
            ];
        
         let sessionConstants:NSDictionary = [
            "SESSION_TYPE_GLOBAL": MapmyIndiaSessionType.global.rawValue,
            "SESSION_TYPE_NAVIGATION": MapmyIndiaSessionType.navigation.rawValue,
          ];
        
        let geoanalyticsLayerTypeConstants: NSDictionary = [
            "STATE": MapmyIndiaGeoanalyticsLayerType.state.rawValue,
            "DISTRICT": MapmyIndiaGeoanalyticsLayerType.district.rawValue,
            "SUB_DISTRICT": MapmyIndiaGeoanalyticsLayerType.subDistrict.rawValue,
            "WARD": MapmyIndiaGeoanalyticsLayerType.ward.rawValue,
            "LOCALITY": MapmyIndiaGeoanalyticsLayerType.locality.rawValue,
            "PANCHAYAT": MapmyIndiaGeoanalyticsLayerType.panchayat.rawValue,
            "BLOCK": MapmyIndiaGeoanalyticsLayerType.block.rawValue,
            "PINCODE": MapmyIndiaGeoanalyticsLayerType.pincode.rawValue,
            "TOWN": MapmyIndiaGeoanalyticsLayerType.town.rawValue,
            "CITY": MapmyIndiaGeoanalyticsLayerType.city.rawValue,
            "VILLAGE": MapmyIndiaGeoanalyticsLayerType.village.rawValue,
            "SUB_LOCALITY": MapmyIndiaGeoanalyticsLayerType.subLocality.rawValue,
            "SUB_SUB_LOCALITY": MapmyIndiaGeoanalyticsLayerType.subSubLocality.rawValue,
        ];
                
                return [
                    "AutoSuggestCriteria":autosuggestConstants,
                    "GeoCodingCriteria":geoCodeConstants,
                    "NearbyCriteria":nearbyConstants,
                    "DirectionsCriteria":directionConstants,
                    "POICriteria":poiConstants,
                    "SessionCriteria":sessionConstants,
                    "GeoAnalyticsType":geoanalyticsLayerTypeConstants,
                ] as NSDictionary
              }

    
    @objc(reverseGeocode:withResolver:withRejecter:)
    func reverseGeocode(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
        if(options["latitude"]==nil){
            reject(REQUIRED_CODE,"Please provide latitude parameter",nil)
            return
        }
        
        if(options["longitude"]==nil){
            reject(REQUIRED_CODE,"Please provide longitude parameter",nil)
            return
        }
        
        let reverseGeocodeManager = MapmyIndiaReverseGeocodeManager.shared
        if let option = RestAPIHelper.reverseGeocodeOption(argument: options) {
            reverseGeocodeManager.reverseGeocode(option) { (placemarks, attribution, error) in
                if let error = error {
                    reject(String(error.code),error.localizedDescription,nil)
                } else {
                    let theJSONText = RestAPIHelper.reverseGeocodeResponse(response: placemarks ?? [])
                    resolve("\(theJSONText ?? "")")
                }
            }
        }else {
            reject("-1","Something went wrong",nil)
        }
        
      }
    
    
    @objc(geocode:withResolver:withRejecter:)
    func geocode(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
        if(options["address"]==nil){
            reject(REQUIRED_CODE,"Please provide address parameter",nil)
            return
        }
        
        let geocodeManager = MapmyIndiaAtlasGeocodeManager.shared
        if let option = RestAPIHelper.geocodeOption(argument: options) {
            geocodeManager.getGeocodeResults(option) {(response, error) in
            if let error = error {
                reject(String(error.code),error.localizedDescription,nil)
            } else {
                let theJSONText = RestAPIHelper.geocodeResponse(response: response)
                resolve("\(theJSONText ?? "")")
            }
            }
        }else {
            reject("-1","Something went wrong",nil)
        }
        
    }
    
    @objc(autoSuggest:withResolver:withRejecter:)
    func autoSuggest(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
        if(options["query"]==nil){
            reject(REQUIRED_CODE,"Please provide query parameter",nil)
            return
        }
        
        let autoSuggestManager = MapmyIndiaAutoSuggestManager.shared
        let option = RestAPIHelper.autosuggestOption(argument: options)
        if(option != nil) {
            autoSuggestManager.getAutoSuggestionResults(option!){ (suggestions, error) in
            if let error = error {
                reject(String(error.code),error.localizedDescription,nil)
            } else {
                let response = suggestions as? MapmyindiaAutoSuggestLocationResults
                let theJSONText = RestAPIHelper.autosuggestResponse(response: response)
                resolve("\(theJSONText ?? "")")
            }
            }
        } else {
            reject("-1","Something went wrong",nil)
        }
        
    }
    
    @objc(nearby:withResolver:withRejecter:)
    func nearby(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
        if(options["keyword"]==nil){
            reject(REQUIRED_CODE,"Please provide keyword parameter",nil)
            return
        }
        
        if(options["location"]==nil){
            reject(REQUIRED_CODE,"Please provide location parameter",nil)
            return
        }
        
        let nearByManager = MapmyIndiaNearByManager.shared
        if let option = RestAPIHelper.nearbyOption(argument: options) {
        nearByManager.getNearBySuggestions(option) { (nearbyResult, error) in
                if let error = error {
                    reject(String(error.code),error.localizedDescription,nil)
                }else {
                    let theJSONText = RestAPIHelper.nearbyResponse(response: nearbyResult)
                    resolve("\(theJSONText ?? "")")
                }
        }
        } else {
            reject("-1","Something went wrong",nil)
        }
        
    }
    
    
    @objc(distance:withResolver:withRejecter:)
    func distance(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
         if(options["coordinates"]==nil){
            reject(REQUIRED_CODE,"Please provide coordinates parameter",nil)
            return
        }
        let coordinates = options["coordinates"] as! [String]
        
        if(coordinates.count<2){
            reject(REQUIRED_CODE,"Please provide atleast two coordinates",nil)
            return
        }
        
        
        let distanceManager = MapmyIndiaDrivingDistanceMatrixManager.shared
        if let option = RestAPIHelper.distanceMatrix(argument: options) {
        distanceManager.getResult(option) { (distanceResult, error) in
                if let error = error {
                    reject(String(error.code),error.localizedDescription,nil)
                }else {
                    let theJSONText = RestAPIHelper.distanceMatrixResponse(response: distanceResult)
                    resolve("\(theJSONText ?? "")")
                }
        }
        } else {
            reject("-1","Something went wrong",nil)
        }
    }
    
    
    @objc(placeDetail:withResolver:withRejecter:)
    func placeDetail(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
         if(options["eLoc"]==nil){
            reject(REQUIRED_CODE,"Please provide eLoc parameter",nil)
            return
        }
       
        let placeDetailManager = MapmyIndiaPlaceDetailManager.shared
        if let option = RestAPIHelper.placeDetailOption(argument: options) {
            placeDetailManager.getResults(option) { (placeDetail, error) in
                    if let error = error {
                        reject(String(error.code),error.localizedDescription,nil)
                    } else {
                        let theJSONText = RestAPIHelper.placeDetailResponse(response: placeDetail)
                        resolve("\(theJSONText ?? "")")
                    }
            }
        } else {
            reject("-1","Something went wrong",nil)
        }
    }
    
    @objc(placeDetailLegacy:withResolver:withRejecter:)
    func placeDetailLegacy(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
         if(options["eLoc"]==nil){
            reject(REQUIRED_CODE,"Please provide eLoc parameter",nil)
            return
        }
       
        let placeDetailLegacyManager = MapmyIndiaPlaceDetailLegacyManager.shared
        if let option = RestAPIHelper.placeDetailLegacyOption(argument: options) {
            placeDetailLegacyManager.getPlaceDetail(option) { (placeDetail, attribution, error) in
                if let error = error {
                    reject(String(error.code),error.localizedDescription,nil)
                } else {
                    let theJSONText = RestAPIHelper.placeDetailLegacyResponse(response: placeDetail)
                    resolve("\(theJSONText ?? "")")
                }
            }
          } else {
            reject("-1","Something went wrong",nil)
         }
    }
    
    @objc(POIAlongRoute:withResolver:withRejecter:)
    func POIAlongRoute(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
         if(options["category"]==nil){
            reject(REQUIRED_CODE,"Please provide category parameter",nil)
            return
        }
        
        if(options["path"]==nil){
           reject(REQUIRED_CODE,"Please provide path parameter",nil)
           return
       }
       
        let poiAlongRouteManager = MapmyIndiaPOIAlongTheRouteManager.shared
        if let option = RestAPIHelper.poiAlongRouteOption(argument: options) {
//        let path = "\(options["path"] as! String)"
//                let poiAlongTheRouteOptions = MapmyIndiaPOIAlongTheRouteOptions(path: path, category: "FODCOF")
//                poiAlongTheRouteOptions.buffer = 1000
            poiAlongRouteManager.getPOIsAlongTheRoute(option) { (response, error) in

                if let error = error {
                    reject(String(error.code),error.localizedDescription,nil)
                }else {
                    let theJSONText = RestAPIHelper.poiAlongRouteResponse(response: response)
                    resolve("\(theJSONText ?? "")")
                }
                
            }
        } else {
            reject("-1","Something went wrong",nil)
        }
    }
    
    @objc(feedback:withResolver:withRejecter:)
    func feedback(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
         if(options["typedKeyword"]==nil){
            reject(REQUIRED_CODE,"Please provide typedKeyword parameter",nil)
            return
        }
        
        if(options["eLoc"]==nil){
           reject(REQUIRED_CODE,"Please provide eLoc parameter",nil)
           return
       }
        
        if(options["index"]==nil){
           reject(REQUIRED_CODE,"Please provide index parameter",nil)
           return
       }
        if(options["appVersion"]==nil){
           reject(REQUIRED_CODE,"Please provide appVersion parameter",nil)
           return
       }
        if(options["locationName"]==nil){
           reject(REQUIRED_CODE,"Please provide locationName parameter",nil)
           return
       }
        if(options["userName"]==nil){
           reject(REQUIRED_CODE,"Please provide userName parameter",nil)
           return
       }
        if(options["latitude"]==nil){
           reject(REQUIRED_CODE,"Please provide latitude parameter",nil)
           return
       }
        if(options["longitude"]==nil){
           reject(REQUIRED_CODE,"Please provide longitude parameter",nil)
           return
       }
       
        let feedbackManager = MapmyIndiaFeedbackManager.shared
        if let option = RestAPIHelper.feedbackOption(argument: options) {
            feedbackManager.sendFeedback(option) { (created, error) in
                if let error = error {
                    reject(String(error.code),error.localizedDescription,nil)
                }else {
                    resolve("success")
                }
            }
        } else {
            reject("-1","Something went wrong",nil)
        }
    }
    
    @objc(direction:withResolver:withRejecter:)
    func direction(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
         if(options["origin"]==nil){
            reject(REQUIRED_CODE,"Please provide origin parameter",nil)
            return
        }
        
        if(options["destination"]==nil){
           reject(REQUIRED_CODE,"Please provide destination parameter",nil)
           return
       }
       
        let directionManager = Directions(restKey: MapmyIndiaAccountManager.restAPIKey())
        if let option = RestAPIHelper.directionOption(argument: options) {
            directionManager.calculate(option) { (waypoints, routes, error) in
                if let error = error {
                    reject(String(error.code),error.localizedDescription,nil)
                }else {
                    let theJSONText = RestAPIHelper.directionResponse(response: routes ?? [], waypoints: waypoints ?? [], geometry: option.shapeFormat)
                    resolve("\(theJSONText ?? "")")
                }
            }
        } else {
            reject("-1","Something went wrong",nil)
        }
    }
    
    @objc(textSearch:withResolver:withRejecter:)
    func textSearch(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
         if(options["query"]==nil){
            reject(REQUIRED_CODE,"Please provide query parameter",nil)
            return
        }
        
       
        let textSearchManager = MapmyIndiaAtlasTextSearchManager.shared
        if let option = RestAPIHelper.textSearchOption(argument: options) {
            textSearchManager.getTextSearchResult(option) { (suggestions, error) in
                if let error = error {
                    reject(String(error.code),error.localizedDescription,nil)
                } else {
                    let theJSONText = RestAPIHelper.autosuggestResponse(response: suggestions)
                    resolve("\(theJSONText ?? "")")
                }

            }
        } else {
            reject("-1","Something went wrong",nil)
        }
    }
    
    @objc(hateosnearby:withResolver:withRejecter:)
    func hateosnearby(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
         if(options["hyperlink"]==nil){
            reject(REQUIRED_CODE,"Please provide hyperlink parameter",nil)
            return
        }
        
       
        let hateOsManager = MapmyIndiaHateOSManager.shared
        if let option = RestAPIHelper.hateOsNearbyOption(argument: options) {
            hateOsManager.getResults(option) { (nearbyResponse, error) in
                if let error = error {
                    reject(String(error.code),error.localizedDescription,nil)
                } else {
                    let theJSONText = RestAPIHelper.hateOsNearbyResponse(response: nearbyResponse)
                    resolve("\(theJSONText ?? "")")
                }
            }
        } else {
            reject("-1","Something went wrong",nil)
        }
    }
    	
    @objc(clusterLinkedDevices:withResolver:withRejecter:)
    func clusterLinkedDevices(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
         if(options["clusterId"]==nil){
            reject(REQUIRED_CODE,"Please provide clusterId parameter",nil)
            return
        }
        
        var sessionType = MapmyIndiaSessionType.global

        if(options["sessionType"] != nil){
            let seesionTypeString  = options["sessionType"] as! String
            sessionType = MapmyIndiaSessionType(rawValue: seesionTypeString)
       }
       
        let clusterLinkedDevicesManager = MapmyIndiaClusterLinkedDevicesManager(clientId: MapmyIndiaAccountManager.clusterId(), clientSecret: MapmyIndiaAccountManager.atlasClientSecret(), grantType: MapmyIndiaAccountManager.atlasGrantType(), sessionType: sessionType)
        if  let clusterLinkedDevicesOptions = RestAPIHelper.clusterLinkedDevicesOption(argument: options) {
            clusterLinkedDevicesManager.getClusterLinkedDevices(clusterLinkedDevicesOptions) { (devices, error) in
                if let error = error {
                    reject(String(error.code),error.localizedDescription,nil)
                } else if let devices = devices {
                    let theJSONText = RestAPIHelper.clusterLinkedDevicesResponse(response: devices)
                    resolve("\(theJSONText ?? "")")
                }
            }
        } else {
            reject("-1","Something went wrong",nil)
        }
             
    }
    
    
    @objc(deleteClusterLinkedDevice:withResolver:withRejecter:)
    func deleteClusterLinkedDevice(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
         if(options["clusterId"]==nil){
            reject(REQUIRED_CODE,"Please provide clusterId parameter",nil)
            return
        }
        
        if(options["linkedDevice"]==nil){
           reject(REQUIRED_CODE,"Please provide linkedDevice parameter",nil)
           return
       }
        
        var sessionType = MapmyIndiaSessionType.global

        if(options["sessionType"] != nil){
            let seesionTypeString  = options["sessionType"] as! String
            sessionType = MapmyIndiaSessionType(rawValue: seesionTypeString)
       }
        
        //let deleteClusterLinkedDevicesManager = MapmyIndiaDeleteClusterLinkedDeviceManager.shared
        let deleteClusterLinkedDevicesManager = MapmyIndiaDeleteClusterLinkedDeviceManager(clientId: MapmyIndiaAccountManager.clusterId(), clientSecret: MapmyIndiaAccountManager.atlasClientSecret(), grantType: MapmyIndiaAccountManager.atlasGrantType(), sessionType: sessionType)
        if let deleteClusterLinkedDevicesOptions = RestAPIHelper.deleteClusterLinkedDeviceOption(argument: options){
            deleteClusterLinkedDevicesManager.deleteClusterLinkedDevice(deleteClusterLinkedDevicesOptions) { (isSccuess, error) in
                if let error = error {
                    reject(String(error.code),error.localizedDescription,nil)
                    }else if isSccuess {
                        resolve("success")
                    }
                }
        }else {
            reject("-1","Something went wrong",nil)
        }
               
             
    }
    
    
    @objc(endSession:withResolver:withRejecter:)
    func endSession(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
         if(options["clusterId"]==nil){
            reject(REQUIRED_CODE,"Please provide clusterId parameter",nil)
            return
        }
        
        
        var sessionType = MapmyIndiaSessionType.global

        if(options["sessionType"] != nil){
            let seesionTypeString  = options["sessionType"] as! String
            sessionType = MapmyIndiaSessionType(rawValue: seesionTypeString)
       }
        
             //let endSessionManager = MapmyIndiaEndSessionManager.shared
        let endSessionManager = MapmyIndiaEndSessionManager(clientId: MapmyIndiaAccountManager.clusterId(), clientSecret: MapmyIndiaAccountManager.atlasClientSecret(), grantType: MapmyIndiaAccountManager.atlasGrantType(), sessionType: sessionType)
        if  let endSessionOptions = RestAPIHelper.endSessionOption(argument: options){
            endSessionManager.endSession(endSessionOptions) { (isSuccess, error) in
                if let error = error {
                    reject(String(error.code),error.localizedDescription,nil)
                    }else if isSuccess {
                        resolve("success")
                    }
        }
            
        } else {
            reject("-1","Something went wrong",nil)
        }
               }
    
    @objc(geoAnalyticsList:withResolver:withRejecter:)
    func geoAnalyticsList(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
         if(options["api"]==nil){
            reject(REQUIRED_CODE,"Please provide api parameter",nil)
            return
        }
        
        if(options["geoBoundType"]==nil){
           reject(REQUIRED_CODE,"Please provide geoBoundType parameter",nil)
           return
       }
        
        if(options["geoBound"]==nil){
           reject(REQUIRED_CODE,"Please provide geoBound parameter",nil)
           return
       }
        
        if(options["attributes"]==nil){
           reject(REQUIRED_CODE,"Please provide attributes parameter",nil)
           return
       }
        
        
        if  let listingRequest = RestAPIHelper.geoAnalyticsListOption(argument: options){
            let listingManager = MapmyIndiaGeoanalyticsListingManager.shared()
            listingManager.getListingInfo(listingRequest) { (response, err) in
                let error = err as NSError?
                if let error = error {
                    reject(String(error.code), error.localizedDescription,nil)
                } else {
                    let theJSONText = RestAPIHelper.geoAnalyticsListResponse(response: response)
                    resolve("\(theJSONText ?? "")")
                }
        }
        
        } else {
            reject("-1","Something went wrong",nil)
        }
    }
    
    @objc(roadTrafficDetail:withResolver:withRejecter:)
    func roadTrafficDetail(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
        
        if let location  = options["location"] as? NSDictionary {
            if(location["latitude"] == nil || location["longitude"] == nil){
            reject(REQUIRED_CODE,"Please provide latitude or longitude parameter",nil)
            return
          }
        }else{
            reject(REQUIRED_CODE,"Please provide location parameter",nil)
           return
        }
        
        
        if  let trafficDetailRequest = RestAPIHelper.roadTrafficDetailOption(argument: options){
            
            let trafficDetailManger = MapmyIndiaRoadTrafficDetailsManager.shared;
            trafficDetailManger.getTrafficRoadDetailsResults(trafficDetailRequest) { response, error in
                if let error = error {
                    reject(String(error.code), error.localizedDescription,nil)
                    } else {
                let theJSONText = RestAPIHelper.roadTrafficDetailsResponse(response: response)
                resolve("\(theJSONText ?? "")")
                }
            }
        } else {
            reject("-1","Something went wrong",nil)
        }
    }
    
    @objc(generateOtp:withResolver:withRejecter:)
    func generateOtp(userHandle: NSString,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
    
        
        let otpManger = MapmyIndiaOtpGenerateManager.shared;
        let otpOptions = MapmyIndiaOtpGenerateOptions.init(userHandle: userHandle as String);
        otpManger.getOtp(otpOptions) { location, error in
            if let error = error {
                    reject(String(error.code), error.localizedDescription,nil)
                } else {
               
                resolve(location)
            }
        }

    }
    
    @objc(whiteList:withResolver:withRejecter:)
    func whiteList(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
        
        if(options["url"]==nil){
           reject(REQUIRED_CODE,"Please provide url parameter",nil)
           return
       }
        
        if(options["userHandle"]==nil){
           reject(REQUIRED_CODE,"Please provide userHandle parameter",nil)
           return
       }
        
        if(options["otp"]==nil){
           reject(REQUIRED_CODE,"Please provide otp parameter",nil)
           return
       }
        
        
        if  let whiteListRequest = RestAPIHelper.whiteListOption(argument: options){
            
            let whitelistManager = MapmyIndiaWhitelistManager.shared;
            
            whitelistManager.whitelistUser(whiteListRequest) { isSuccess, error in
                if let error = error {
                    reject(String(error.code), error.localizedDescription,nil);
                } else {
                    resolve(nil);
             }
            }

        } else {
            reject("-1","Something went wrong",nil)
        }
    }
    
    
    @objc(nearbyReports:withResolver:withRejecter:)
    func nearbyReports(options: NSDictionary,withReslover resolve:@escaping RCTPromiseResolveBlock,withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
        
         if(options["topLeft"]==nil){
            reject(REQUIRED_CODE,"Please provide topLeft parameter",nil)
            return
        }
        
        if(options["bottomRight"]==nil){
           reject(REQUIRED_CODE,"Please provide bottomRight parameter",nil)
           return
       }
        
       
        
        
        if  let nearbyReportRequest = RestAPIHelper.nearbyReportOption(argument: options){
           
            let nearbyReportManager =  MapmyIndiaNearbyReportManager.shared
            
            nearbyReportManager.getNearbyReportResult(nearbyReportRequest) { placemarks, error in
                if let error = error {
                    reject(String(error.code), error.localizedDescription,nil);
                    } else {
                        let theJSONText = RestAPIHelper.nearbyReportResponse(response: placemarks);
                        resolve("\(theJSONText ?? "")");
                    }
            }
            
        } else {
            reject("-1","Something went wrong",nil)
        }
    }
}
