let lookAheadDistancesInMeters = [1000.0, 500.0, 250.0]
let trailingDistanceInMeters = 500.0
let electronicHorizonOptions = ElectronicHorizonOptions(
    lookAheadDistancesInMeters: lookAheadDistancesInMeters,
    trailingDistanceInMeters: trailingDistanceInMeters
)

let transportMode = TransportMode.car

do {
    electronicHorizonEngine = try ElectronicHorizonEngine(
        sdkEngine: ElectronicHorizonHandler.getSDKNativeEngine(),
        options: electronicHorizonOptions,
        transportMode: transportMode,
        route: route
    )
} catch let instantiationError {
    fatalError("ElectronicHorizonEngine is not initialized: \(instantiationError)")
}

electronicHorizonEngine.update(mapMatchedLocation: mapMatchedLocation)

private func createElectronicHorizonDelegate() -> ElectronicHorizonDelegate {
    class EHDelegate: ElectronicHorizonDelegate {
        weak var handler: ElectronicHorizonHandler?

        init(handler: ElectronicHorizonHandler) {
            self.handler = handler
        }

        func onElectronicHorizonUpdated(error: ElectronicHorizonError?, update: ElectronicHorizonUpdate?) {
            guard error == nil, let electronicHorizonUpdate = update else {
                print("(ElectronicHorizonHandler.LOG_TAG): ElectronicHorizonUpdate error: \(String(describing: error))")
                return
            }
            // Asynchronously start to load required data for the new segments.
            // Use the ElectronicHorizonDataLoaderStatusDelegate to get notified when new data is arriving.
            if electronicHorizonUpdate.electronicHorizon != nil {
                handler?.lastRequestedElectronicHorizon = electronicHorizonUpdate.electronicHorizon
            }
            if let segmentChanges = update.segmentChanges {
                handler?.electronicHorizonDataLoader.loadData(electronicHorizonUpdate: electronicHorizonUpdate)
            }
        }
    }
    return EHDelegate(handler: self)
}

// Many more options are available, see SegmentDataLoaderOptions in the API Reference.
var segmentDataLoaderOptions = SegmentDataLoaderOptions()
segmentDataLoaderOptions.loadRoadSigns = true
segmentDataLoaderOptions.loadSpeedLimits = true
segmentDataLoaderOptions.loadRoadAttributes = true

// The cache size defines how many road segments are cached locally. A larger cache size
// can reduce data usage, but requires more storage memory in the cache.
let segmentDataCacheSize = 10
do {
    electronicHorizonDataLoader = try ElectronicHorizonDataLoader(
        sdkEngine: ElectronicHorizonHandler.getSDKNativeEngine(),
        options: segmentDataLoaderOptions,
        segmentDataCacheSize: Int32(segmentDataCacheSize)
    )
} catch let instantiationError {
    fatalError("ElectronicHorizonDataLoader is not initialized: \(instantiationError)")
}

/// Handle newly arriving map data segments provided by the ElectronicHorizonDataLoader.
/// This delegate is called when the status of the data loader is updated and new segments have been loaded.
private func createElectronicHorizonDataLoaderStatusDelegate() -> ElectronicHorizonDataLoaderStatusDelegate {
    class EHStatusDelegate: ElectronicHorizonDataLoaderStatusDelegate {
        weak var handler: ElectronicHorizonHandler?

        init(handler: ElectronicHorizonHandler) {
            self.handler = handler
        }

        func onElectronicHorizonDataLoaderStatusUpdated(electronicHorizonDataLoaderStatuses statusMap: [Int32: ElectronicHorizonDataLoadedStatus]) {
            print("\(ElectronicHorizonHandler.LOG_TAG): ElectronicHorizonDataLoaderStatus updated.")
            // Access the loaded segments here.
        }
    }

    return EHStatusDelegate(handler: self)
}

for (level, status) in statusMap {
    // The integer key represents the level of the most preferred path (0) and side paths (1, 2, ...).
    // This example shows only how to look at the fully loaded segments of the most preferred path (level 0).
    if level == 0 && status == .fullyLoaded {
        // Now, level 0 segments have been fully loaded and you can access their data.
        // The electronicHorizonPaths list contains segments from all levels,
        // so you need to filter for level 0 below.
        for electronicHorizonPath in lastUpdate.electronicHorizonPaths {
            let electronicHorizonPathSegments = electronicHorizonPath.segments
            for segment in electronicHorizonPathSegments {
                // For any segment you can check the parentPathIndex to determine
                // if it is part of the most preferred path (MPP) or a side path.
                if segment.parentPathIndex != 0 {
                    // Skip side path segments as we only want to log MPP segment data in this example.
                    // And we only want to log fully loaded segments.
                    continue
                }

                guard let directedOCMSegmentId = segment.segmentId.ocmSegmentId else {
                    continue
                }

                // Retrieving segment data from the loader is executed synchronous. However, since the data has been
                // already loaded, this is a fast operation.
                let result = handler.electronicHorizonDataLoader.getSegment(segmentId: directedOCMSegmentId.id)
                if result.errorCode == nil, let segmentData = result.segmentData {
                    // Access the data that was requested to be loaded in SegmentDataLoaderOptions.
                    // For this example, we just log road signs.
                    guard let roadSigns = segmentData.roadSigns, !roadSigns.isEmpty else {
                        continue
                    }
                    for roadSign in roadSigns {
                        let roadSignCoordinates = handler.getGeoCoordinatesFromOffsetInMeters(
                            geoPolyline: segmentData.polyline,
                            offsetInMeters: Double(roadSign.offsetInMeters)
                        )
                        print("\(ElectronicHorizonHandler.LOG_TAG): RoadSign: type = \(roadSign.roadSignType.rawValue), offsetInMeters = \(roadSign.offsetInMeters), lat/lon: \(roadSignCoordinates.latitude)/\(roadSignCoordinates.longitude), segmentId = \(directedOCMSegmentId.id.localId)")
                    }
                }
            }
        }
    }
}

/// Convert an offset in meters along a GeoPolyline to GeoCoordinates using the HERE SDK's coordinatesAtOffsetInMeters.
private func getGeoCoordinatesFromOffsetInMeters(geoPolyline: GeoPolyline, offsetInMeters: Double) -> heresdk.GeoCoordinates {
    return geoPolyline.coordinatesAt(offsetInMeters: offsetInMeters,
                                     direction: .fromBeginning)
}

electronicHorizonEngine.removeElectronicHorizonListener(listener);
electronicHorizonDataLoader.removeElectronicHorizonDataLoaderStatusListener(statusListener);