let plannedChargingStopWaypoint = Waypoint(coordinates: chargingStopGeoCoordinates)

// The rated power of the connector, in kilowatts (kW).
let powerInKilowatts: Double = 350.0

// The rated current of the connector, in amperes (A).
let currentInAmperes: Double = 350.0

// The rated voltage of the connector, in volts (V).
let voltageInVolts: Double = 1000.0

// The minimum duration (in seconds) the user plans to charge at the station.
let minimumDuration = TimeInterval(3000)

// The maximum duration (in seconds) the user plans to charge at the station.
let maximumDuration = TimeInterval(4000)

// Add a user-defined charging stop.
//
// Note: To specify a ChargingStop, you must also set totalCapacityInKilowattHours,
// initialChargeInKilowattHours, and chargingCurve using BatterySpecifications in ElectricVehicleOptions.
// If any of these values are missing, the route calculation will fail with an invalid parameter error.
let plannedChargingStop = ChargingStop(
    powerInKilowatts: powerInKilowatts,
    currentInAmperes: currentInAmperes,
    voltageInVolts: voltageInVolts,
    supplyType: .dc,
    minDuration: minimumDuration,
    maxDuration: maximumDuration
)

plannedChargingStopWaypoint.chargingStop = plannedChargingStop

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

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

    // Use routes from list.
}

private func applyEMSPPreferences(evOptions: inout ElectricVehicleOptions) {
    // You can get a list of all E-Mobility Service Providers and their partner IDs by using the request described here:
    // https://www.here.com/docs/bundle/ev-charge-points-api-developer-guide/page/topics/example-charging-station.html.
    // The RoutingEngine will follow the priority order you specify when calculating routes, so try to specify at least most preferred providers.
    // Note that this may impact the route geometry.

    // Most preferred provider for route calculation: As an example, we use "Jaguar Charging" referenced by the partner ID taken from above link.
    let preferredProviders: [String] = ["3379b852-cca5-11ed-8856-42010aa40002"]

    // Example code for a least preferred provider.
    let leastPreferredProviders: [String] = ["12345678-abcd-0000-0000-000000000000"]

    // Alternative provider for route calculation to be used only when no better options are available.
    // Example code for an alternative provider.
    let alternativeProviders: [String] = ["12345678-0000-abcd-0000-000123456789"]

    evOptions.evMobilityServiceProviderPreferences = EVMobilityServiceProviderPreferences()
    evOptions.evMobilityServiceProviderPreferences.high = preferredProviders;
    evOptions.evMobilityServiceProviderPreferences.low = leastPreferredProviders;
    evOptions.evMobilityServiceProviderPreferences.medium = alternativeProviders;
}

private func getEVRoutingOptions() -> RoutingOptions {
    var routingOptions = RoutingOptions()

    // Configure a data-driven EV energy consumption model that combines empirically
    // derived vehicle parameters with speed and elevation characteristics.
    var empiricalConsumptionModel = EmpiricalConsumptionModel()
    // The below three options are the minimum you must specify or routing will result in an error.
    empiricalConsumptionModel.ascentConsumptionInWattHoursPerMeter = 9
    empiricalConsumptionModel.descentRecoveryInWattHoursPerMeter = 4.3
    empiricalConsumptionModel.freeFlowSpeedTable = [0: 0.239,
                                                        27: 0.239,
                                                        60: 0.196,
                                                        90: 0.238]

    var evOptions = ElectricVehicleOptions()

    // Set the empirical consumption model so the EV routing
    // can estimate energy usage based on speed and elevation.
    evOptions.empiricalConsumptionModel = empiricalConsumptionModel

    // Must be 0 for isoline calculation.
    routingOptions.routeOptions.alternatives = 0

    // Ensure that the vehicle does not run out of energy along the way
    // and charging stations are added as additional waypoints.
    evOptions.ensureReachability = true

    // The below options are required when setting the ensureReachability option to true
    // (AvoidanceOptions need to be empty).
    routingOptions.avoidanceOptions = AvoidanceOptions()
    routingOptions.routeOptions.speedCapInMetersPerSecond = nil
    routingOptions.routeOptions.optimizationMode = .fastest

    var batterySpecifications = BatterySpecifications()
    batterySpecifications.connectorTypes = [.tesla, .iec62196Type1Combo, .iec62196Type2Combo]
    batterySpecifications.totalCapacityInKilowattHours = 80.0
    batterySpecifications.initialChargeInKilowattHours = 10.0
    batterySpecifications.targetChargeInKilowattHours = 72.0
    batterySpecifications.chargingCurve = [0: 239.0,
                                                        64: 111.0,
                                                        72: 1.0]
    evOptions.batterySpecifications = batterySpecifications

    // Apply EV mobility service provider preferences (eMSP).
    applyEMSPPreferences(evOptions: &evOptions)

    routingOptions.evOptions = evOptions

    // Note: More EV options are available, the above shows only the minimum viable options.

    return routingOptions
}

// Find inserted charging stations that are required for this route.
// Note that this example assumes only one start waypoint and one destination waypoint.
// By default, each route has one section.
let additionalSectionCount = route.sections.count - 1
if (additionalSectionCount > 0) {
    // Each additional waypoint splits the route into two sections.
    print("Number of required stops at charging stations: \(additionalSectionCount)")
} else {
    print("Based on the provided options, the destination can be reached without a stop at a charging station.")
}

var sectionIndex = 0
let sections = route.sections
for section in sections {
    print("Estimated net energy consumption in kWh for this section: \(String(describing: section.consumptionInKilowattHours))")
    for postAction in section.postActions {
        switch postAction.action {
            case .chargingSetup:
                print("At the end of this section you need to setup charging for \(postAction.duration) s.")
            break
            case .charging:
                print("At the end of this section you need to charge for \(postAction.duration) s.")
            break
            case .wait:
                print("At the end of this section you need to wait for \(postAction.duration) s.")
            break
            default: fatalError("Unknown post action type.")
        }
    }

    print("Section \(sectionIndex): Estimated battery charge in kWh when leaving the departure place: \(String(describing: section.departurePlace.chargeInKilowattHours))")
    print("Section \(sectionIndex): Estimated battery charge in kWh when leaving the arrival place: \(String(describing: section.arrivalPlace.chargeInKilowattHours))")

    // Only charging stations that are needed to reach the destination are listed below.
    let depStation = section.departurePlace.chargingStation
    if depStation != nil  && !chargingStationsIDs.contains(depStation?.id ?? "-1") {
        print("Section \(sectionIndex), name of charging station: \(String(describing: depStation?.name))")
        chargingStationsIDs.append(depStation?.id ?? "-1")
        addCircleMapMarker(geoCoordinates: section.departurePlace.mapMatchedCoordinates, imageName: "required_charging.png")
    }

    let arrStation = section.departurePlace.chargingStation
    if arrStation != nil && !chargingStationsIDs.contains(arrStation?.id ?? "-1") {
        print("Section \(sectionIndex), name of charging station: \(String(describing: arrStation?.name))")
        chargingStationsIDs.append(arrStation?.id ?? "-1")
        addCircleMapMarker(geoCoordinates: section.arrivalPlace.mapMatchedCoordinates, imageName: "required_charging.png")
    }

    sectionIndex += 1
}

private func logSpanConsumption(route: Route) {
    var sectionIndex = 0
    for section in route.sections {
        var spanIndex = 0
        for span in section.spans {
            if let kWh = span.consumptionInKilowattHours {
                print("EVSpan: Section \(sectionIndex) span \(spanIndex) consumption: \(String(format: "%.3f", kWh)) kWh")
            } else {
                print("EVSpan: Section \(sectionIndex) span \(spanIndex) consumption: n/a")
            }
            spanIndex += 1
        }
        sectionIndex += 1
    }
}

private func logSectionArrivalCharge(route: Route) {
    var sectionIndex = 0
    var lastSectionArrivalChargeKWh: Double?

    for routeSection in route.sections {
        let remainingChargeAtArrivalKWh = routeSection.arrivalPlace.chargeInKilowattHours

        if let charge = remainingChargeAtArrivalKWh {
            print("EVArrival: Section \(sectionIndex): remaining charge upon arrival = \(String(format: "%.2f", charge)) kWh")
            lastSectionArrivalChargeKWh = charge
        } else {
            print("EVArrival: Section \(sectionIndex): remaining charge upon arrival not available")
        }
        sectionIndex += 1
    }

    if let finalCharge = lastSectionArrivalChargeKWh {
        print("EVArrival: Final destination arrival charge = \(String(format: "%.2f", finalCharge)) kWh")
        if finalCharge < 0.0 {
            print("EVArrival: Destination not reachable with the current battery configuration.")
        }
    } else {
        print("EVArrival: No arrival charge data available for any section in this route.")
    }
}

private var lastPlannedChargingStopWaypoint: Waypoint?

private func verifyAndLogPlannedStopOutcome(route: Route) {
    if lastPlannedChargingStopWaypoint == nil {
        print("EVChargingStop: No user-planned charging stop to verify.")
        return
    }

    let coordinateMatchRadiusMeters = 200.0
    var isStopIncludedInRoute = false
    var matchedChargingStationName: String?

    let plannedStopCoordinates = lastPlannedChargingStopWaypoint!.coordinates

    for routeSection in route.sections {
        if let departureStation = routeSection.departurePlace.chargingStation {
            let departureStationCoordinates = routeSection.departurePlace.mapMatchedCoordinates
            if departureStationCoordinates.distance(to: plannedStopCoordinates) <= coordinateMatchRadiusMeters {
                isStopIncludedInRoute = true
                matchedChargingStationName = departureStation.name
                break
            }
        }

        if let arrivalStation = routeSection.arrivalPlace.chargingStation {
            let arrivalStationCoordinates = routeSection.arrivalPlace.mapMatchedCoordinates
            if arrivalStationCoordinates.distance(to: plannedStopCoordinates) <= coordinateMatchRadiusMeters {
                isStopIncludedInRoute = true
                matchedChargingStationName = arrivalStation.name
                break
            }
        }
    }

    if isStopIncludedInRoute {
        let suffix = matchedChargingStationName != nil ? " (≈ \(matchedChargingStationName!))." : "."
        print("EVChargingStop: User-defined charging stop was included in the calculated route\(suffix)")
    } else {
        print("EVChargingStop: User-defined charging stop was adjusted or replaced during route optimization.")
    }
}