//
//  RestAPIHelper.swift
//  mapmyindia_gl
//
//  Created by CEINFO on 20/05/21.
//

import Foundation
import MapmyIndiaAPIKit
import MapmyIndiaDirections
import MapmyIndiaMaps
import MapmyIndiaGeoanalytics

class RestAPIHelper {
    
    class func autosuggestOption(argument: Any?) -> MapmyIndiaAutoSearchAtlasOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        let option = MapmyIndiaAutoSearchAtlasOptions.init(query: options["query"] as! String)
        if let location = options["location"] as? NSDictionary {
            
            let lat = location["latitude"] as! Double
            let lng = location["longitude"] as! Double
            
            option.location = CLLocation(latitude: lat, longitude:lng)
        }
        if let zoom = options["zoom"] as? NSNumber {
            option.zoom = zoom
        }
        if(options.keys.contains("tokenizeAddress")) {
            if let tokenizeAddress =  options["tokenizeAddress"] as? Bool {
                option.includeTokenizeAddress = tokenizeAddress
            }
        }
        if(options.keys.contains("pod")) {
            option.pod = MMIPodTypeIdentifier(options["pod"] as! String)
        }
        if(options.keys.contains("bridge")) {
            option.isBridgeEnabled = options["bridge"] as! Bool
        }
        if(options.keys.contains("hyperLocal")) {
            option.hyperLocal = options["hyperLocal"] as! Bool
        }
        if let filter = options["filter"] as? String {
            if(filter.contains("bounds")) {
                let filterArray = filter.components(separatedBy: ":")
                let boundsArray = filterArray[1].components(separatedBy: ";")
                let firstBound = boundsArray[0].components(separatedBy: ",")
                let secondBound = boundsArray[1].components(separatedBy: ",")
                let firstLng=(firstBound[1] as NSString).doubleValue
                let firstLat=(firstBound[0] as NSString).doubleValue
                let secondLng=(secondBound[1] as NSString).doubleValue
                let secondLat=(secondBound[0] as NSString).doubleValue
                
                let southwest = CLLocationCoordinate2D(latitude: firstLat, longitude: firstLng)
                let northeast = CLLocationCoordinate2D(latitude: secondLat, longitude: secondLng)
                option.filter = MapmyIndiaBoundsFilter(bounds: MapmyIndiaRectangularRegion(topLeft: northeast, bottomRight: southwest))
            } else if(filter.contains("cop")) {
                let filterArray = filter.components(separatedBy: ":")
                option.filter = MapmyIndiaElocFilter(placeId: filterArray[1])
            }
        }
        return option
    }
    
    class func geocodeOption(argument: Any?) -> MapmyIndiaAtlasGeocodeOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        let geocodeOptions = MapmyIndiaAtlasGeocodeOptions.init(query: options["address"] as! String)
        if let bias = options["bias"] as? NSNumber {
            //Need to check
        }
        if let bound = options["bound"] as? String {
            //Need to check
        }
        if let itemCount = options["itemCount"] as? NSNumber {
            geocodeOptions.maximumResultCount = itemCount.uintValue
        }
        if let podFilter = options["podFilter"] as? String {
            //Need to check
        }
        
        return geocodeOptions
        
    }
    
    class func reverseGeocodeOption(argument: Any?) -> MapmyIndiaReverseGeocodeOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        if let latitude = options["latitude"] as? Double,
           let longitude = options["longitude"] as? Double{
        
            return MapmyIndiaReverseGeocodeOptions.init(coordinate:CLLocationCoordinate2D(latitude: latitude, longitude:longitude))
            
        }
        return nil
        
    }
    
    class func nearbyOption(argument: Any?) -> MapmyIndiaNearbyAtlasOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        let location: String = options["location"] as! String;
        
        let nearbyOption = MapmyIndiaNearbyAtlasOptions.init(query: options["keyword"] as! String, location: location)
        if let page = options["page"] as? NSNumber {
            nearbyOption.page = page
        }
        if let radius = options["radius"] as? NSNumber {
            nearbyOption.radius = radius
        }
        if let pod = options["pod"] as? String {
            nearbyOption.pod = MMIPodTypeIdentifier.init(rawValue: pod)
        }
        if let bounds = options["bounds"] as? String {
            let boundsArray = bounds.components(separatedBy: ";")
            let firstBound = boundsArray[0].components(separatedBy: ",")
            let secondBound = boundsArray[1].components(separatedBy: ",")
            let firstLng=(firstBound[1] as NSString).doubleValue
            let firstLat=(firstBound[0] as NSString).doubleValue
            let secondLng=(secondBound[1] as NSString).doubleValue
            let secondLat=(secondBound[0] as NSString).doubleValue
            
            let southwest = CLLocationCoordinate2D(latitude: firstLat, longitude: firstLng)
            let northeast = CLLocationCoordinate2D(latitude: secondLat, longitude: secondLng)
            nearbyOption.bounds = MapmyIndiaRectangularRegion.init(topLeft: northeast, bottomRight: southwest)
        }
        if let filter = options["filter"] as? String {
            let filterArray = filter.components(separatedBy: ":")
            nearbyOption.filters =  [MapmyIndiaNearbyKeyValueFilter(filterKey: filterArray[0], filterValues: [filterArray[1]])]
        }
        if let explain = options["explain"] as? Bool {
            nearbyOption.shouldExplain = explain
        }
        if let richData = options["richData"] as? Bool {
            nearbyOption.isRichData = richData
        }
        if let searchBy = options["searchBy"] as? String {
            nearbyOption.searchBy = MMISearchByType.init(searchBy)
        }
        if let sortBy = options["sortBy"] as? String {
            if sortBy == "dist:asc" || sortBy == "dist:desc" {
                nearbyOption.sortBy = MapmyIndiaSortByDistanceWithOrder(orderBy: MMISortByOrderType.init(sortBy))
            } else if sortBy == "name:asc" || sortBy == "name:desc" {
                //Need to check
            }
        }
        if let userName = options["userName"] as? String {
            nearbyOption.userName = userName
        }
        return nearbyOption
    }
    
    class func directionOption(argument: Any?) -> RouteOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        var waypointList: [Waypoint] = [Waypoint]()
        if let originPoint = options["origin"] as? String {
                waypointList.append(Waypoint(eLoc: originPoint))
        }

        if let waypointPoint = options["waypoints"] as? [Any] {
            for item in waypointPoint {
                let location = item as! String
                waypointList.append(Waypoint(eLoc: location	))
            }
        }
//        if let waypointELoc = options["waypointELoc"] as? [Any] {
//            for item in waypointELoc {
//                let location = item as! String
//                waypointList.append(Waypoint(eLoc: location))
//            }
//        }
        if let destinationPoint = options["destination"] as? String {
//            if(destinationPoint.contains(",")){
//              let destinationCoor =   options["destination"] as! [Double]
//                waypointList.append(Waypoint(coordinate: CLLocationCoordinate2D.init(latitude: destinationCoor[0], longitude: destinationCoor[1])))
//            }else{
                waypointList.append(Waypoint(eLoc: destinationPoint))
            //}
        }

        let directionOptions = RouteOptions.init(waypoints: waypointList)
        directionOptions.profileIdentifier = options["profile"] != nil ? MBDirectionsProfileIdentifier.init(options["profile"] as! String) : MBDirectionsProfileIdentifier.driving
        directionOptions.resourceIdentifier = options["resource"] != nil ?  MBDirectionsResourceIdentifier.init(options["resource"] as! String) : MBDirectionsResourceIdentifier.routeAdv
        directionOptions.routeShapeResolution = options["overview"] != nil ?  RouteShapeResolution.init(description: options["overview"] as! String)! : .full
//        directionOptions.shapeFormat = RouteShapeFormat.init(description: options["geometries"] as! String) ?? .polyline6
        if let polylineType = options["geometries"] as? String {
            if polylineType == "polyline" {
                directionOptions.shapeFormat = .polyline
            } else {
                directionOptions.shapeFormat = .polyline6
            }
        } else {
            directionOptions.shapeFormat = .polyline6
        }
        if let excludes = options["excludes"] as? [String] {
            var avoidClasses: MBRoadClasses = MBRoadClasses()
            avoidClasses = RoadClasses.init(descriptions: excludes)!
            directionOptions.roadClassesToAvoid = avoidClasses
        }
        if let annotations = options["annotations"] as? [String] {
            var attributionArray: MBAttributeOptions = MBAttributeOptions()
            attributionArray = AttributeOptions.init(descriptions: annotations)!
            directionOptions.attributeOptions = attributionArray
        }
        if let routeType = options["routeType"] as? Int {
            directionOptions.routeType = MapmyIndiaRouteType.init(rawValue: routeType)!
        }
        if let steps = options["steps"] as? Bool {
            directionOptions.includesSteps = steps
        }
        if let alternatives = options["alternatives"] as? Bool {
            directionOptions.includesAlternativeRoutes = alternatives
        }
        if let bearing = options["bearing"] as? [String: Any?] {
            //Need to check
        }
        if let bannerInstructions = options["bannerInstructions"] as? Bool {
            directionOptions.includesVisualInstructions = bannerInstructions
        }
        if let isSort = options["isSort"] as? Bool {
            directionOptions.sorted = isSort
        }
        if let lessVerbose = options["lessVerbose"] as? Bool {
             directionOptions.lessVerbose = lessVerbose
        }
        if let radiuses = options["radiuses"] as? [Double] {
            //Need to check
        }
        
        if let approches = options["approaches"] as? [String] {
            //Need to check
        }
        
        if let waypointIndices = options["waypointIndices"] as? [Any] {
            //Need to check
        }
        
        if let waypointNames = options["waypointNames"] as? [String] {
            //Need to check
        }
        
        if let waypointTargets = options["waypointTargets"] as? [Any] {
            //need to check
        }
        
        
        if let routeRefresh = options["routeRefresh"] as? Bool {
            directionOptions.routeRefresh = routeRefresh
        }
        if let deviceId = options["deviceId"] as? String {
            //            directionOptions.deviceId = deviceId
        }
        if let roundaboutExits = options["roundaboutExits"] as? Bool {
            directionOptions.includesExitRoundaboutManeuver = roundaboutExits
        }
        if let sessionId = options["sessionId"] as? String {
            directionOptions.prevRouteSessionId = sessionId
        }
        if let voiceInstructions = options["voiceInstructions"] as? Bool {
            directionOptions.includesSpokenInstructions = voiceInstructions
        }
        if let voiceUnits = options["voiceUnits"] as? String {
            directionOptions.distanceMeasurementSystem = MeasurementSystem.init(description: voiceUnits)!
        }
        
        return directionOptions
    }
    
    class func distanceMatrix(argument: Any?) -> MapmyIndiaDrivingDistanceMatrixOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        if let coordinates = options["coordinates"] as? [String] {
            let distanceMatrixOption = MapmyIndiaDrivingDistanceMatrixOptions.init(locations: coordinates)
            if let profile = options["profile"] as? String {
                distanceMatrixOption.profileIdentifier =   MapmyIndiaDirectionsProfileIdentifier.init(profile)
            }
            
            if let resource = options["resource"] as? String {
                distanceMatrixOption.resourceIdentifier = MapmyIndiaDistanceMatrixResourceIdentifier.init(resource)
            }
            if let sources = options["sources"] as? [Int] {
                distanceMatrixOption.sourceIndexes = sources
            }
            if let destinations = options["destinations"] as? [Int] {
                distanceMatrixOption.destinationIndexes = destinations
            }
            if let routeType = options["routeType"] as? NSNumber {
                distanceMatrixOption.routeType = MMIDistanceRouteType.init(rawValue: routeType.intValue) ?? .none
            }
            return distanceMatrixOption
        } else {
            return nil
        }
    }
    
    class func feedbackOption(argument: Any?) -> MapmyIndiaFeedbackOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        let lat = options["latitude"] as! Double
        let lng = options["longitude"] as! Double
        return MapmyIndiaFeedbackOptions.init(typedKeyword: options["typedKeyword"] as! String, selectedEloc: options["eLoc"] as! String, selectedLocationName: options["locationName"] as! String, selectedIndex: options["index"] as! Int, username: options["userName"] as! String, appVersion: options["appVersion"] as! String, latitude: lat, longitude: lng)
    }
    
    class func poiAlongRouteOption(argument: Any?) -> MapmyIndiaPOIAlongTheRouteOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        let poiAlongRouteOptions = MapmyIndiaPOIAlongTheRouteOptions.init(path: options["path"] as! String, category: options["category"] as! String)
        let geometries = options["geometries"] as? String;
        if geometries == "polyline6" {
            poiAlongRouteOptions.geometries = .polyline6
        } else if geometries == "polyline" {
            poiAlongRouteOptions.geometries = .polyline5
        } else {
            poiAlongRouteOptions.geometries = .base64
        }
        if let buffer = options["buffer"] as? Int {
            poiAlongRouteOptions.buffer = buffer
        }
        if let page = options["page"] as? Int {
            poiAlongRouteOptions.page = page
        }
        if let sort = options["sort"] as? Bool {
            poiAlongRouteOptions.sort = sort
        }
        return poiAlongRouteOptions
    }
    
    class func textSearchOption(argument: Any?) -> MapmyIndiaTextSearchAtlasOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        let textSearchOptions = MapmyIndiaTextSearchAtlasOptions.init(query: options["query"] as! String)
        if let location = options["location"] as? [Double] {
            textSearchOptions.refLocation = CLLocation(latitude: location[0], longitude:location[1])
        }
        if let username = options["username"] as? NSNumber {
            //            textSearchOptions.username = username
        }
        if let explain = options["explain"] as? Bool {
            //Need to check
        }
        if(options.keys.contains("bridge")) {
            //Need to check
        }
        if let filter = options["filter"] as? String {
            //Need tocheck
            //            if(filter.contains("bounds")) {
            //                let filterArray = filter.components(separatedBy: ":")
            //                let boundsArray = filterArray[1].components(separatedBy: ";")
            //                let firstBound = boundsArray[0].components(separatedBy: ",")
            //                let secondBound = boundsArray[1].components(separatedBy: ",")
            //                let firstLng=(firstBound[1] as NSString).doubleValue
            //                let firstLat=(firstBound[0] as NSString).doubleValue
            //                let secondLng=(secondBound[1] as NSString).doubleValue
            //                let secondLat=(secondBound[0] as NSString).doubleValue
            //
            //                let southwest = CLLocationCoordinate2D(latitude: firstLat, longitude: firstLng)
            //                let northeast = CLLocationCoordinate2D(latitude: secondLat, longitude: secondLng)
            //                textSearchOptions.filter = MapmyIndiaBoundsFilter(bounds: MapmyIndiaRectangularRegion(topLeft: northeast, bottomRight: southwest))
            //            } else if(filter.contains("cop")) {
            //                let filterArray = filter.components(separatedBy: ":")
            //                textSearchOptions.filter = MapmyIndiaElocFilter(placeId: filterArray[1])
            //            }
        }
        
        return textSearchOptions
        
    }
    
    class func placeDetailOption(argument: Any?) -> MapmyIndiaPlaceDetailOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        return MapmyIndiaPlaceDetailOptions.init(eLoc: options["eLoc"] as! String)
    }
    
    class func placeDetailLegacyOption(argument: Any?) -> MapmyIndiaPlaceDetailLegacyOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        return MapmyIndiaPlaceDetailLegacyOptions.init(placeId: options["eLoc"] as! String)
    }
    
    class func hateOsNearbyOption(argument: Any?) -> MapmyIndiaHateOSOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        return MapmyIndiaHateOSNearbyOptions.init(hyperlink: URL(string: options["hyperlink"] as! String)!)
    }
    
    class func clusterLinkedDevicesOption(argument: Any?) -> MapmyIndiaClusterLinkedDevicesOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        
        let clusterLinkedDevicesOptions = MapmyIndiaClusterLinkedDevicesOptions(sessionDevice: options["clusterId"] as! String);
        return clusterLinkedDevicesOptions;
    
    }
    
    class func deleteClusterLinkedDeviceOption(argument: Any?) -> MapmyIndiaDeleteClusterLinkedDeviceOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        let deleteClusterLinkedDevicesOptions = MapmyIndiaDeleteClusterLinkedDeviceOptions(sessionDevice: options["clusterId"] as! String , linkedDevice: options["linkedDevice"] as! String)
        return deleteClusterLinkedDevicesOptions;
    
    }
    
    class func endSessionOption(argument: Any?) -> MapmyIndiaEndSessionOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        let endSessionOptions = MapmyIndiaEndSessionOptions(sessionDevice: options["clusterId"] as! String)
        return endSessionOptions;
    
    }
    
    
    class func geoAnalyticsListOption(argument: Any?) -> GeoanalyticsListingAPIRequest? {
        guard let options = argument as? [String: Any] else { return nil}
        
        return GeoanalyticsListingAPIRequest.init(geoboundType: options["geoBoundType"] as! String, geobound: options["geoBound"] as! [String], attribute: options["attributes"] as! String, api: MapmyIndiaGeoanalyticsLayerType.init(rawValue: options["api"] as! String))
    }
    
    class func nearbyReportOption(argument: Any?) -> MapmyindiaNearbyReportOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        
        let mTopLeft = options["topLeft"] as! [Double];
        let mBottomRight = options["bottomRight"] as! [Double];
        
        let topleft = CLLocationCoordinate2D(latitude: mTopLeft[1], longitude: mTopLeft[0])
        let bottomRight = CLLocationCoordinate2D(latitude: mBottomRight[1], longitude: mBottomRight[0])

        let bound = MapmyIndiaRectangularRegion(topLeft: topleft, bottomRight: bottomRight)
         return MapmyindiaNearbyReportOptions(bound: bound)
    }
    
    class func roadTrafficDetailOption(argument: Any?) -> MapmyIndiaRoadTrafficDetailsOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        
        let location = options["location"] as! NSDictionary;
        let lat = location["latitude"] as! Double;
        let lng  = location["longitude"] as! Double;
        
        let trafficDetailOptions = MapmyIndiaRoadTrafficDetailsOptions.init(latitude: lat, longitude: lng);
        
        if let radius = options["radius"] as? Int {
            trafficDetailOptions.radius = radius;
        }
        
        return trafficDetailOptions;
    }
    
    class func whiteListOption(argument: Any?) -> MapmyIndiaWhitelistOptions? {
        guard let options = argument as? [String: Any] else { return nil}
        
        let url = options["url"] as! String;
        let userHandle = options["userHandle"] as! String;
        let otp = options["otp"] as! String;

        
        return MapmyIndiaWhitelistOptions.init(userHandle: userHandle, passPhrase: otp, refLocation:url);
    }
    
    class func autosuggestResponse(response: MapmyindiaAutoSuggestLocationResults?) -> String? {
        var suggestedLocations: Array<Any> = [Any]()
        let suggestions = response?.suggestions ?? []
        for item  in suggestions {
            var data : [String: Any] =    ["eLoc" :item.eLoc ?? "" ,
                                           "placeName": item.placeName ?? "" ,
                                           "placeAddress": item.placeAddress ?? "" ,
                                           "longitude": "\(item.longitude ?? NSNumber())",
                                           "latitude": "\(item.latitude ?? NSNumber())",
                                           "type": item.type ?? "",
                                           "entryLatitude": item.entryLatitude ?? Double(0.0),
                                           "entryLongitude": item.entryLongitude ?? Double(0.0),
                                           "orderIndex": item.orderIndex ?? NSNumber(),
                                           "keywords": item.keywords ?? [String](),
                                           "typeX": item.typeX ?? NSNumber()]
            
            if let addressToken = item.addressTokens {
               // let tokenizeAddress : [String: Any] =
                data["addressTokens"] = ["poi": addressToken.poi ,
                                         "city": addressToken.city ,
                                         "district":addressToken.district,
                                         "houseName": addressToken.houseName ,
                                         "houseNumber": addressToken.houseNumber ,
                                         "locality": addressToken.locality ,
                                         "pincode": addressToken.pincode ,
                                         "state": addressToken.state,
                                         "street": addressToken.street,
                                         "subDistrict": addressToken.subDistrict,
                                         "subLocality": addressToken.subLocality ,
                                         "subSubLocality": addressToken.subSubLocality ,
                                         "village": addressToken.village]
            }
            suggestedLocations.append(data)
            
        }
        var userAddedLocations: Array<Any> = [Any]()
        let userAddedSearches = response?.userAddedLocations ?? []
        for item in userAddedSearches {
            let data: [String: Any?] = ["eLoc" :item.eLoc ?? "",
                                       "placeName": item.placeName ?? "" ,
                                       "placeAddress": item.placeAddress ?? "" ,
                                       "longitude": "\(item.longitude ?? NSNumber())",
                                       "latitude": "\(item.latitude ?? NSNumber())",
                                       "type": item.type ?? "",
                                       "entryLatitude": item.entryLatitude ?? Double(0.0),
                                       "entryLongitude": item.entryLongitude ?? Double(0.0),
                                       "orderIndex": item.orderIndex ?? NSNumber(0),
                                       "user": item.userName ?? "",

                                       "keywords": item.keywords ?? [String](),
                                       "typeX": item.typeX ?? NSNumber(0)]
            userAddedLocations.append(data)
        }
        let suggestedSearches = response?.suggestedSearches ?? []
        var suggestedSearchesArray: Array<Any> = [Any]()
        for item in suggestedSearches {
            let data : [String: Any?] = [
                "keyword": item.keyword,
                "identifier": item.identifier,
                "location": item.location,
                "hyperLink": item.hyperLink,
                "orderIndex": item.orderIndex,
                "eLoc": item.eLoc
            ]
            suggestedSearchesArray.append(data)
        }
        
        let dict: [String: Any?] = [
            "suggestedLocations": suggestedLocations,
            "suggestedSearches": suggestedSearchesArray,
            "userAddedLocations": userAddedLocations
        ]
        return toJson(data: dict)
        
    }
    
    class func textSearchResponse(response: [MapmyIndiaAtlasSuggestion]) -> String? {
            var suggestedLocations: Array<Any> = [Any]()
            for item  in response {
                var data : [String: Any] =    ["eLoc" :item.eLoc ?? "" ,
                                                       "placeName": item.placeName ?? "" ,
                                                       "placeAddress": item.placeAddress ?? "" ,
                                                       "longitude": "\(item.longitude ?? NSNumber())",
                                                       "latitude": "\(item.latitude ?? NSNumber())",
                                                       "type": item.type ?? "",
                                                       "entryLatitude": item.entryLatitude ?? Double(0.0),
                                                       "entryLongitude": item.entryLongitude ?? Double(0.0),
                                                       "orderIndex": item.orderIndex ?? NSNumber(),
                                                    
                                                       "keywords": item.keywords ?? [String](),
                                                       "typeX": item.typeX ?? NSNumber()]
                
                if let addressToken = item.addressTokens {

                data["addressTokens"] = ["poi": addressToken.poi,
                                         "city": addressToken.city,
                                         "district":addressToken.district,
                                         "houseName": addressToken.houseName,
                                         "houseNumber": addressToken.houseNumber,
                                         "locality": addressToken.locality,
                                         "pincode": addressToken.pincode,
                                         "state": addressToken.state,
                                         "street": addressToken.street,
                                         "subDistrict": addressToken.subDistrict,
                                         "subLocality": addressToken.subLocality,
                                         "subSubLocality": addressToken.subSubLocality,
                                         "village": addressToken.village]
                }
                suggestedLocations.append(data)
                 
            }
            
            let dict: [String: Any?] = [
            "suggestedLocations": suggestedLocations
                //User added location
                //Suggested searches
            ]
            return toJson(data: dict)
            
        }
    
    class func geocodeResponse(response: MapmyIndiaAtlasGeocodeAPIResponse?) -> String? {
        guard let response = response else {
            return nil
        }
        var results: Array<Any> = [Any]()
        if let placemarks = response.placemarks {
            for item in placemarks {
                let data: [String: Any?] = [
                    "houseNumber": item.houseNumber,
                    "houseName": item.houseName,
                    "poi": item.poi,
                    "street": item.street,
                    "subSubLocality": item.subSubLocality,
                    "subLocality": item.subLocality,
                    "locality": item.locality,
                    "village": item.village,
                    "subDistrict": item.subDistrict,
                    "district": item.district,
                    "city": item.city,
                    "state": item.state,
                    "pincode": item.pincode,
                    "formattedAddress": item.formattedAddress,
                    "eLoc": item.eLoc,
                    "latitude": item.latitude,
                    "longitude": item.longitude,
                    "geocodeLevel": item.geocodeLevel
                ]
                results.append(data)
            }
        }
        
        let dict: [String: Any?] = ["results": results]
        return toJson(data: dict)
        
    }
    
    class func reverseGeocodeResponse(response: [MapmyIndiaGeocodedPlacemark]) -> String? {
        var results: Array<Any> = [Any]()
        for item in response {
            let data: [String: Any?] = [
                "area": item.area,
                "houseNumber": item.houseNumber,
                "houseName": item.houseName,
                "poi": item.poi,
                "poi_dist": item.poiDist,
                "street": item.street,
                "street_dist": item.streetDist,
                "subSubLocality": item.subSubLocality,
                "subLocality": item.subLocality,
                "locality": item.locality,
                "village": item.village,
                "subDistrict": item.subDistrict,
                "district": item.district,
                "city": item.city,
                "state": item.state,
                "pincode": item.pincode,
                "formatted_address": item.formattedAddress,
                "place_id": item.placeId,
                "lat": item.latitude,
                "lng": item.longitude
            ]
            results.append(data)
            
        }
        
        let dict: [String: Any?] = ["results": results, "responseCode": 200]
        return toJson(data: dict)
    }
    
    class func nearbyResponse(response: NearbyResult?) -> String? {
        guard let response = response else {return nil}
        var suggestedLocations: [Any] = [Any]()
        if let nearbyResults = response.suggestions {
            for item in nearbyResults {
                let addressToken = item.addressTokens
                var data: [String: Any?] = [
                    "distance": item.distance,
                    "eLoc": item.eLoc,
                    "email": item.email,
                    "entryLatitude": item.entryLatitude,
                    "entryLongitude": item.entryLongitude,
                    "keywords": item.keywords,
                    "landlineNo": item.landlineNo,
                    "latitude": item.latitude,
                    "longitude": item.longitude,
                    "mobileNo": item.mobileNo,
                    "orderIndex": item.orderIndex,
                    "placeAddress": item.placeAddress,
                    "placeName": item.placeName,
                    "type": item.type,
                    "categoryCode": item.categoryCode,
                    "hourOfOperation": item.hourOfOperation,
                    "richInfo": item.richInfoDictionary]
                if addressToken != nil {
                    data["addressTokens"] = ["poi": addressToken?.poi,
                                             "city": addressToken?.city,
                                             "district":addressToken?.district,
                                             "houseName": addressToken?.houseName,
                                             "houseNumber": addressToken?.houseNumber,
                                             "locality": addressToken?.locality,
                                             "pincode": addressToken?.pincode,
                                             "state": addressToken?.state,
                                             "street": addressToken?.street,
                                             "subDistrict": addressToken?.subDistrict,
                                             "subLocality": addressToken?.subLocality,
                                             "subSubLocality": addressToken?.subSubLocality,
                                             "village": addressToken?.village]
                    
                }
                suggestedLocations.append(data)
            }
        }
        var pageInfo: [String: Any?] = [:]
        if let page = response.pageInfo {
            pageInfo = [
                "pageCount": page.pageCount,
                "totalHits": page.totalHits,
                "totalPages": page.totalPages,
                "pageSize": page.pageSize
            ]
        }
        let dict: [String: Any?] = [
            "suggestedLocations": suggestedLocations,
            "pageInfo": pageInfo
        ]
        return toJson(data: dict)
    }
    
    
    class func directionResponse(response: [Route], waypoints: [Waypoint], geometry: RouteShapeFormat) -> String? {
        var dict: [String: Any?] = ["code": "OK"]
        var routes: [Any] = [Any]()
        var wayPointList: [Any] = [Any]()
        
        
        for location in waypoints {
            var data: [String: Any?] = [
                "location": [location.coordinate.longitude, location.coordinate.latitude],
                "name": location.name
            ]
            wayPointList.append(data)
        }
        dict["waypoints"] = wayPointList
        for item in response {
            
            var data: [String: Any?] = [
                "distance": item.distance,
                "duration": item.expectedTravelTime,
                "geometry": item.geometry, //getGeometryString(coordinateList: item.coordinates, geometries: geometry),
                "routeIndex": response.index(of: item)
            ]
            if item.legs != nil {
                var legList: [Any] = [Any]()
                for legs in item.legs {
                    var legsDict: [String: Any?] = [
                        "distance": legs.distance,
                        "duration": legs.expectedTravelTime,
                        "summary": legs.description
                    ]
                    var stepsList: [Any] = [Any]()
                    for steps in legs.steps {
                        var stepsDict: [String: Any?] = [
                            "distance": steps.distance,
                            "duration": steps.expectedTravelTime,
                            "geometry": getGeometryString(coordinateList: steps.coordinates, geometries: geometry),
                            "name": steps.names?.count ?? 0 > 0 ? steps.names![0]: nil,
                            "destinations": steps.destinations?.count ?? 0 > 0 ? steps.destinations![0]: nil,
                            "mode": steps.transportType.description,
                            "pronunciation": steps.instructions,
                            "rotary_name": steps.exitNames?.count ?? 0 > 0 ? steps.exitNames![0]: nil,
                            "rotary_pronunciation": steps.phoneticExitNames?.count ?? 0 > 0 ? steps.phoneticExitNames![0]: nil,
                            "driving_side": steps.drivingSide.description,
                            "maneuver": [
                                //                                "degree": steps.,
                                "location": [steps.maneuverLocation.longitude, steps.maneuverLocation.latitude],
                                "bearing_before": steps.initialHeading,
                                "bearing_after": steps.finalHeading,
                                "instruction": steps.instructions,
                                "type": steps.maneuverType.description,
                                "modifier": steps.maneuverDirection.description,
                                "exit": steps.exitIndex
                            ]
                        ]
                        if let voiceInstruction = steps.instructionsSpokenAlongStep {
                            var voiceInstuctionList = [Any]()
                            for spokenInstruction in voiceInstruction {
                                let spokenDict: [String: Any?] = [
                                    "distanceAlongGeometry": spokenInstruction.distanceAlongStep,
                                    "announcement": spokenInstruction.text,
                                    "ssmlAnnouncement": spokenInstruction.ssmlText
                                ]
                                voiceInstuctionList.append(spokenDict)
                            }
                            stepsDict["voiceInstructions"] = voiceInstuctionList
                        }
                        if let intersections = steps.intersections {
                            var intersectionList = [Any]()
                            for stepsintersection in intersections {
                                var intersectionDict: [String: Any?] = [
                                    "location": [stepsintersection.location.longitude, stepsintersection.location.latitude],
                                    "bearings": stepsintersection.headings,
                                    "classes": stepsintersection.outletRoadClasses,
                                    "entry": stepsintersection.outletIndexes,
                                    "in": stepsintersection.approachIndex,
                                    "out": stepsintersection.outletIndex
                                ]
                                if let lanes = stepsintersection.approachLanes {
                                    var lanesList = [Any]()
                                    for laneItem in lanes {
                                        lanesList.append([
                                            //                                            "valid": laneItem.
                                            "indications": laneItem.indications
                                        ])
                                    }
                                    intersectionDict["lanes"] = lanesList
                                }
                            }
                            stepsDict["intersections"] = intersectionList
                        }
                        
                        stepsList.append(stepsDict)
                    }
                    legsDict["steps"] = stepsList
                    legsDict["annotation"] = [
                        "distance": legs.segmentDistances,
                        "duration": legs.expectedSegmentTravelTimes,
                        "speed": legs.segmentSpeeds,
                        "congestion": legs.segmentCongestionLevels?.map { $0.description }
                        //                        "baseDuration": legs.base
                        //                        "nodes": legs.
                        //                        "maxspeed": legs.segmen
                    ]
                    legList.append(legsDict)
                }
                data["legs"] = legList
            }
            
            var coordinates: [String] = [String]()
            for waypoint in item.routeOptions.waypoints {
                if(waypoint.coordinate != nil) {
                    coordinates.append("\(waypoint.coordinate.longitude),\(waypoint.coordinate.latitude)")
                } else {
                    coordinates.append(waypoint.eLoc!)
                }
            }
            var routeOption: [String: Any?] = [
                //                "deviceID": item.routeOptions.
                //                "user": item.routeOptions.user
                "profile": item.routeOptions.profileIdentifier.rawValue,
                "resource": item.routeOptions.resourceIdentifier.rawValue,
                "coordinates": coordinates,
                "alternatives": item.routeOptions.includesAlternativeRoutes,
                //                "radiuses": item.routeOptions.rad
                //                "bearings": item.routeOptions.
                //                "language": item.routeOptions.lan
                //                "lessverbose": item.routeOptions.less
                "geometries": item.routeOptions.shapeFormat.description,
                "overview": item.routeOptions.routeShapeResolution.description,
                "steps": item.routeOptions.includesSteps,
                "annotations": item.routeOptions.attributeOptions.description,
                "exclude": item.routeOptions.roadClassesToAvoid.description,
            ]
            
            data["routeOptions"] = routeOption
            routes.append(data)
        }
        dict["routes"] = routes
        
        return toJson(data: dict)
    }
    
    class func getGeometryString(coordinateList: [CLLocationCoordinate2D]?, geometries: RouteShapeFormat)-> String? {
        guard let coordinateList = coordinateList else {return nil}
        if geometries == .polyline6 {
            return PolylineUtility(coordinates: coordinateList,precision: 1e6).encodedPolyline
        } else if geometries == .polyline {
            return PolylineUtility(coordinates: coordinateList,precision: 1e5).encodedPolyline
        } else {
            var coordinates = [Any]()
            for location in coordinateList {
                
                var points = [Any]()
                points.append("\(location.longitude)")
                points.append("\(location.latitude)")
                coordinates.append(points)
            }
            let jsonDic: [String: Any] = [
                "type": "FeatureCollection",
                "features": [
                    [
                        "type": "Feature",
                        "properties": ["name": "geojson-1"],
                        "geometry": [
                            "type": "LineString",
                            "coordinates": coordinates
                        ]
                    ]
                ]
            ]
            return toJson(data: jsonDic)
        }
    }
    
    class func distanceMatrixResponse(response: MapmyIndiaDrivingDistanceMatrixResponse?) -> String? {
        guard let response = response else {return nil}
        var dict: [String:Any?] = [
            "responseCode": response.responseCode,
            "version": response.version
        ]
        if let results = response.results {
            let data: [String: Any?] = [
                "code": results.code,
                "distances": results.distances,
                "durations": results.durations
            ]
            dict["results"] = data
        }
        return toJson(data: dict)
    }
    
    class func poiAlongRouteResponse(response: [MapmyIndiaPOISuggestion]?) -> String? {
        guard let response = response else {return nil}
        var dict: [String:Any?] = [:]
        var suggestedPoi: [Any] = [Any]()
        for item in response {
            let data: [String: Any?] = [
                "distance": item.distance,
                "place_id": item.placeId,
                "poi": item.poi,
                "subSubLocality": item.subSubLocality,
                "subLocality": item.subLocality,
                "locality": item.locality,
                "city": item.city,
                "subDistrict": item.subDistrict,
                "district": item.district,
                "state": item.state,
                "poplrName": item.popularName,
                "address": item.address,
                "tel": item.telephoneNumber,
                "email": item.email,
                "website": item.website,
                "e_lat": item.entryLatitude,
                "e_lng": item.entryLongitude,
                "latitude": item.latitude,
                "longitude": item.longitude,
                "brand_code": item.brandCode
            ]
            suggestedPoi.append(data)
        }
        dict["suggestedPOIs"] = suggestedPoi
        return toJson(data: dict)
    }
    
    class func placeDetailResponse(response: MapmyIndiaPlaceDetail?) -> String? {
        guard let response = response else {return nil}
        var list: [Any] = [Any]()
        if let placeInfo = response.keyInfo {
            for item in placeInfo {
                var valuesList: [Any] = [Any]()
                if let keyInfo = item.values {
                    for values in keyInfo {
                        let valuesData:  [String: Any?] = [
                            "title": values.title,
                            "value": values.value
                        ]
                        valuesList.append(valuesData)
                    }
                }
                let data: [String: Any?] = [
                    "heading": item.heading,
                    "values": valuesList
                ]
                list.append(data)
            }
        }
        let dict: [String: Any?] = [
            "eloc": response.eLoc,
            "latitude": response.latitude?.doubleValue,
            "longitude": response.longitude?.doubleValue,
            "placeName": response.placeName,
            "address": response.address,
            "type": response.type,
            "houseNumber": response.houseNumber,
            "houseName": response.houseName,
            "poi": response.poi,
            "street": response.street,
            "subSubLocality": response.subSubLocality,
            "subLocality": response.subLocality,
            "locality": response.locality,
            "village": response.village,
            "district": response.district,
            "subDistrict": response.subDistrict,
            "city": response.city,
            "state": response.state,
            "pincode": response.pincode,
            "placeKeyInfo": list
        ]
        
        return toJson(data: dict)
    }
    
    class func placeDetailLegacyResponse(response: [MapmyIndiaGeocodedPlacemark]?) -> String? {
        guard let response = response else {return nil}
        var results: Array<Any> = [Any]()
        for item in response {
            let data: [String: Any?] = [
                "area": item.area,
                "city": item.city,
                "district": item.district,
                "formatted_address": item.formattedAddress,
                "houseName": item.houseName,
                "houseNumber": item.houseNumber,
                "lat": item.latitude,
                "lng": item.longitude,
                "locality": item.locality,
                "pincode": item.pincode,
                "poi_dist": item.poiDist,
                "poi": item.poi,
                "state": item.state,
                "street": item.street,
                "street_dist": item.streetDist,
                "subDistrict": item.subDistrict,
                "subLocality": item.subLocality,
                "subSubLocality": item.subSubLocality,
                "village": item.village,
                "place_id": item.placeId
            ]
            results.append(data)
            
        }
        
        let dict: [String: Any?] = ["results": results]
        return toJson(data: dict)
        
    }
    
    class func hateOsNearbyResponse(response: MapmyIndiaLocationResults?) -> String? {
        guard let response = response else {return nil}
        var suggestedLocations: [Any] = [Any]()
        if let nearbyResults = response.suggestions {
            for item in nearbyResults {
                let addressToken = item.addressTokens
                var data: [String: Any?] = [
                    "distance": item.distance,
                    "eLoc": item.eLoc,
                    "email": item.email,
                    "entryLatitude": item.entryLatitude,
                    "entryLongitude": item.entryLongitude,
                    "keywords": item.keywords,
                    "landlineNo": item.landlineNo,
                    "latitude": item.latitude,
                    "longitude": item.longitude,
                    "mobileNo": item.mobileNo,
                    "orderIndex": item.orderIndex,
                    "placeAddress": item.placeAddress,
                    "placeName": item.placeName,
                    "type": item.type,
                    "categoryCode": item.categoryCode,
                    "hourOfOperation": item.hourOfOperation,
                    "richInfo": item.richInfoDictionary]
                if addressToken != nil {
                    data["addressTokens"] = ["poi": addressToken?.poi,
                                             "city": addressToken?.city,
                                             "district":addressToken?.district,
                                             "houseName": addressToken?.houseName,
                                             "houseNumber": addressToken?.houseNumber,
                                             "locality": addressToken?.locality,
                                             "pincode": addressToken?.pincode,
                                             "state": addressToken?.state,
                                             "street": addressToken?.street,
                                             "subDistrict": addressToken?.subDistrict,
                                             "subLocality": addressToken?.subLocality,
                                             "subSubLocality": addressToken?.subSubLocality,
                                             "village": addressToken?.village]
                    
                }
                suggestedLocations.append(data)
            }
        }
//        var pageInfo: [String: Any?] = [:]
//        if let page = response.pageInfo {
//            pageInfo = [
//                "pageCount": page.pageCount,
//                "totalHits": page.totalHits,
//                "totalPages": page.totalPages,
//                "pageSize": page.pageSize
//            ]
//        }
        let dict: [String: Any?] = [
            "suggestedLocations": suggestedLocations,
//            "pageInfo": pageInfo
        ]
        return toJson(data: dict)
    }
    
    class func geoAnalyticsListResponse(response: GeoanalyticsListingAPIsResponse?) -> String? {
        guard let response = response else {return nil}
        var attributeList: [Any] = [Any]();
        if let values = response.results?.getAttrValues {
            for item in values {
            let value: [String: Any?] = [
                "geo_bound": (item as! GeoanalyticsAttributedValues).geoBound,
                "get_attr_values": (item as! GeoanalyticsAttributedValues).attributedValues
            ]
                attributeList.append(value)
            }
        }
        
        let results: [String: Any?] = [
            "api_name": response.results?.apiName,
            "attribute": response.results?.attribute,
            "get_attr_values": attributeList
        ]
        
        let dict: [String: Any?] = [
            "responseCode": NSNumber.init(value: Int(response.responseCode ?? "0") ?? 0) ,
            "total_feature_count": response.totalFeatureCount,
            "version": response.version,
            "results": results
        ]
        return toJson(data: dict)
    }
    
    
    class func roadTrafficDetailsResponse(response: MapmyIndiaRoadTrafficDetailsResponse?) -> String? {
        guard let response = response else {return nil}
      
        let result :[String : Any?]  = [
            "geometry":response.result?.geometry,
            "trafficStatus":response.result?.trafficStatus,
            "trafficType":response.result?.trafficType,
            "distance":response.result?.distance,
            "routeNo":response.result?.routeNo,
            "shoulder":response.result?.shoulder,
            "state":response.result?.state,
            "name":response.result?.name,
            "district":response.result?.district,
            "divider":response.result?.divider,
            "oneway":response.result?.oneway,
            "averageSpeed":response.result?.averageSpeed,
            "roadClass":response.result?.roadClass,
            "numOfLanes":response.result?.numOfLanes,
            "city":response.result?.city,
            "multiCarriageway":response.result?.multiCarriageway,
            "formOfWay":response.result?.formOfWay,
            "speedLimit":response.result?.speedLimit,
            "owner":response.result?.owner,
            
        ];
  
        let dict: [String: Any?] = [
            "responseCode": NSNumber.init(value: Int(response.responseCode ?? "0") ?? 0) ,
            "version": response.version,
            "provider": response.provider,
            "creationTime":response.creationTime,
            "result":result,
        ]
        return toJson(data: dict)
    }
    
    class func nearbyReportResponse(response: MapmyIndiaNearbyReportResponse?) -> String? {
        guard let response = response else {return nil}
        
        var reports: Array<Any> = [Any]()
        if let nativeReports = response.reports {
            for item in nativeReports {
                
                
                let data: [String: Any?] = [
                    "category":item.category,
                    "iconBaseUrl":item.iconBaseUrl,
                    "nearbyReport_description":item.nearbyReport_description,
                    "usersCount":item.usersCount,
                    "expiry":item.expiry,
                    "createdOn":item.createdOn,
                    "addedBy":item.addedBy,
                    "addedByName":item.addedByName,
                    "userProfileIcon":item.userProfileIcon,
                    "reportIcon":item.reportIcon,
                    "bearing":item.bearing,
                    "status":item.status,
                    "longitude":item.longitude,
                    "latitude":item.latitude,
                    "address":item.address,
                    "childCategory":item.childCategory,
                    "parentCategory":item.parentCategory,
                    "id":item.id,
                ]
                reports.append(data)
                
            }
        }
        let pagination : [String : Any?]  = [
            "totalItems": response.pagination?.totalItems,
        ];
  
        let dict: [String: Any?] = [
            "pagination": pagination,
            "reports": reports,
        ]
        return toJson(data: dict)
    }
    
    class func clusterLinkedDevicesResponse(response: [MapmyIndiaClusterLinkedDevice]?) -> String? {
        guard let response = response else {return nil}
        var linkedDevicesList = [Any?]()
        
        for device in response {
            let deviceDict : [String: Any?] = [
                "deviceAlias": device.linkedDevice ?? "",
                "deviceFingerprint": device.alias ?? "",
            ]
            linkedDevicesList.append(deviceDict)
                            }
        return toJson(from: linkedDevicesList as Any)
    }


    
    class func toJson(data: [String: Any?]) -> String? {
        if let theJSONData = try? JSONSerialization.data(
            withJSONObject: data,
            options: []) {
            let theJSONText = String(data: theJSONData,
                                     encoding: .ascii)
            
            return theJSONText
        }
        return nil;
    }
    
   class func toJson(from object:Any) -> String? {
        guard let data = try? JSONSerialization.data(withJSONObject: object, options: []) else {
            return nil
        }
        return String(data: data, encoding: String.Encoding.utf8)
    }
}
