ルート検索を開始する

do {
    try routingEngine = RoutingEngine()
} catch let engineInstantiationError {
    fatalError("Failed to initialize routing engine. Cause: \(engineInstantiationError)")
}

let routingOptions = RoutingOptions()
routingEngine.calculateRoute(with: [Waypoint(coordinates: startGeoCoordinates!),
                                    Waypoint(coordinates: destinationGeoCoordinates!)],
                             options: routingOptions) { (routingError, routes) in

        if let error = routingError {
            self.showDialog(title: "Error while calculating a route:", message: "\(error)")
            return
        }

        let route = routes!.first
        self.showRouteDetails(route: route!)
        self.showRouteOnMap(route: route!)
        self.logRouteViolations(route: route!)
}

// estimatedTravelTimeInSeconds includes traffic delay.
let estimatedTravelTimeInSeconds = route.duration
// Get predictive traffic delay data.
let estimatedTrafficDelayInSeconds = route.trafficDelay
let lengthInMeters = route.lengthInMeters

/**
 * Returns the ETA (as a string in ‘HH:mm’ format) in the current device’s timezone, derived from the estimatedTravelTimeInSeconds, which is sourced from the Route object.
 *
 * - Parameter route: Original route object from RoutingEngine.
 * - Returns: A string representing the ETA in "HH:mm" format.
 */
 func getETAinDeviceTimeZone(route: Route) -> String {
    let estimatedTravelTimeInSeconds = route.duration

    // Get an instance of the Calendar class initialized with the current date and time
    let calendar = Calendar.current
    var dateComponents = DateComponents()
    dateComponents.second = Int(estimatedTravelTimeInSeconds)

    // Add the estimated travel time (in seconds) to the current time
    if let etaDate = calendar.date(byAdding: dateComponents, to: Date()) {
        return getFormattedDate(etaDate)
    } else {
        return ""
    }
}

/**
 * Calculates the estimated time of arrival (ETA) in the destination timezone for a given route.
 * It is possible that the destination can be in a different timezone compared to the source.
 * Therefore, we are also calculating the ETA in the destination timezone. For example, the source can be in Berlin and the destination can be in Dubai.
 *
 * - Parameter route: Original route object from RoutingEngine.
 * - Returns: A string representing the estimated time of arrival in the destination timezone, formatted as "hh:mm".
 */
func getETAinDestinationTimeZone(route: Route) -> String {
    let arrivalLocationTime = getArrivalLocationTime(route:route)
    let destinationDate = arrivalLocationTime.localTime

    // The timeOffset represents the difference between the local time at destination and Coordinated Universal Time (UTC) in minutes.
    let timeOffset = Int(arrivalLocationTime.utcOffset/60)

    return getFormattedDate(destinationDate,timeOffset: timeOffset)
}

/**
 * Calculates the estimated time of arrival (ETA) in Coordinated Universal Time (UTC) for a given route.
 * UTC (Coordinated Universal Time) is the primary time standard by which the world regulates clocks and time.
 *
 * @param route Original route object from RoutingEngine.
 * @return A string representing the estimated time of arrival in UTC, formatted as "HH:mm".
 */
func getEstimatedTimeOfArrivalInUTC(route: Route) -> String {
    let utcDate = getArrivalLocationTime(route: route).utcTime

    // The UTC offset represents the difference in hours and minutes between a specific time zone and Coordinated Universal Time (UTC).
    // It indicates whether the local time is ahead (+) or behind (-) UTC.
    // By using an offset of 0, we ensure that the time being represented is in Coordinated Universal Time (UTC).
    let utcTimeOffset = 0
    return getFormattedDate(utcDate, timeOffset: utcTimeOffset)
}

// Returns the arrival time at the final location of the route.
private func getArrivalLocationTime(route: Route) -> LocationTime {
    let lastSectionIndex = route.sections.count - 1

    // The lastSection contains cumulative duration values that increase sequentially.
    // For instance, if there are two sections, each with a duration of 5 minutes, the first section will reflect a total duration of 5 minutes,
    // while the second section will show a total duration of 10 minutes.
    // This is because the total time includes the initial 5 minutes for the first section, followed by an additional 5 minutes to complete the second section, resulting in a cumulative travel time.
    let lastSection = route.sections[lastSectionIndex]
    return lastSection.arrivalLocationTime!
}

/**
 * Formats the given date to a string representation using the device's default timezone.
 *
 * - Parameter date: The Date object to be formatted.
 * - Returns: A string representing the formatted time in the default timezone.
 */
private func getFormattedDate(_ date: Date) -> String {
    // Create a DateFormatter instance that formats the time in a short format (e.g., "HH:mm a").
    let dateFormatter = DateFormatter()
    dateFormatter.timeStyle = .short

    // Format the date using the configured DateFormatter and return the result as a string.
    return dateFormatter.string(from: date)
}

routeOptions.trafficOptimizationMode = .disabled

for routeRailwayCrossing in route.railwayCrossings {
    // Coordinates of the route offset
    let routeOffsetCoordinates = routeRailwayCrossing.coordinates
    // Index of the corresponding route section. The start of the section indicates the start of the offset.
    let routeOffsetSectionIndex = routeRailwayCrossing.routeOffset.sectionIndex
    // Offset from the start of the specified section to the specified location along the route.
    let routeOffsetInMeters = routeRailwayCrossing.routeOffset.offsetInMeters

    print("A railway crossing of type \(routeRailwayCrossing.type) is situated \(routeOffsetInMeters) meters away from start of section: \(routeOffsetSectionIndex)")
}

// A route may contain several warnings, for example, when a certain route option could not be fulfilled.
// An implementation may decide to reject a route if one or more violations are detected.
private func logRouteViolations(route: Route) {
    let sections = route.sections
    for section in sections {
        for span in section.spans {
            let spanGeometryVertices = span.geometry.vertices;
            // This route violation spreads across the whole span geometry.
            guard let violationStartPoint: GeoCoordinates  = spanGeometryVertices.first else {
                print("Error: violation start geocoordinate is empty.")
                return
            };
            guard let violationEndPoint : GeoCoordinates = spanGeometryVertices.last else {
                print("Error: violation end geocoordinate is empty.")
                return
            };
            for index in span.noticeIndexes{
                let spanSectionNotice : SectionNotice = section.sectionNotices[Int(index)];
                // The violation code such as "violatedVehicleRestriction".
                let violationCode = spanSectionNotice.code;
                print("The violation \(violationCode)  starts at \(toString(geoCoordinates: violationStartPoint))  and ends at  \(toString(geoCoordinates: violationEndPoint)) .");

            }
        }
    }
}