func mapView(_ mapView: MKMapView, rendererFor overlay: MKOverlay) -> MKOverlayRenderer {
    if let polyline = overlay as? MKPolyline {
        let gradientRenderer = MKGradientPolylineRenderer(polyline: polyline)

        gradientRenderer.setColors(
            [Asset.Colors.primary.color, Asset.Colors.cdtRouteGradientLight.color],
            locations: [0.0, 1.0]
        )
        gradientRenderer.lineWidth = 2.0

        return gradientRenderer
    }
    return MKOverlayRenderer(overlay: overlay)
}

let tapGestureRecognizer = UITapGestureRecognizer(target: context.coordinator, action: #selector(context.coordinator.handleMapTap(_:)))
tapGestureRecognizer.delegate = context.coordinator
mapView.addGestureRecognizer(tapGestureRecognizer)

// A function to interpolate UIColor. Returns the color interpolated between two colors based on the fraction value
func interpolateColor(fraction: CGFloat) -> UIColor {
    // Retrieve the RGBA components of the start and end colors
    let fromComponents = Asset.Colors.primary.color.cgColor.components ?? [0, 0, 0, 1]
    let toComponents = Asset.Colors.cdtRouteGradientLight.color.cgColor.components ?? [0, 0, 0, 1]
    
    // Interpolate colors based on the fraction
    let red = fromComponents[0] + (toComponents[0] - fromComponents[0]) * fraction
    let green = fromComponents[1] + (toComponents[1] - fromComponents[1]) * fraction
    let blue = fromComponents[2] + (toComponents[2] - fromComponents[2]) * fraction
    
    return UIColor(red: red, green: green, blue: blue, alpha: 1)
}

// A function to generate polyline information from an array of coordinates
func makePolylines(_ coordinates: [CLLocationCoordinate2D]) -> [PolylineInfo] {
    // Return an empty array If the coordinates array is empty
    guard !coordinates.isEmpty else { return [] }

    // Calculate the chunk size (at least the entire set as one chunk)
    let chunkSize = coordinates.count / 20 > 0 ? coordinates.count / 20 : coordinates.count

    var cumulativeDistance = 0.0
    Let totalDistance = coordinates.totalDistance() // Calculate the total distance

    var previousEndColor: UIColor = Asset.Colors.primary.color
    var previousEndCoordinate: CLLocationCoordinate2D?
    var polylines: [PolylineInfo] = []

    // Divide the coordinates into chunks and process each chunk
    let chunks = stride(from: 0, to: coordinates.count, by: chunkSize)
        .map { startIndex -> [CLLocationCoordinate2D] in
            // Retrieve the coordinates of the chunk and add the last coordinates from the previous chunk
            var chunk = Array(coordinates[startIndex..<min(startIndex + chunkSize, coordinates.count)])
            if let lastCoordinate = previousEndCoordinate {
                chunk.insert(lastCoordinate, at: 0)
            }
            previousEndCoordinate = chunk.last
            return chunk
        }

    for chunk in chunks {
        Let chunkDistance = chunk.totalDistance() // Calculate the distance of the chunk
        Let startFraction = cumulativeDistance / totalDistance // Calculate the fraction for the start point
        cumulativeDistance += chunkDistance
        Let endFraction = cumulativeDistance / totalDistance // Calculate the fraction for the end point

        let startColor = previousEndColor
        let endColor = interpolateColor(fraction: CGFloat(endFraction)) // Calculate end color using interpolation
        previousEndColor = endColor

        // Simplify the polyline (reduce points while maintaining high accuracy)
        let simplified = PolylineSimplifier.simplifyPolyline(chunk, tolerance: 0.00001)
        let polyline = MKPolyline(coordinates: simplified, count: simplified.count)

        // Add the polyline information to the list
        polylines.append(PolylineInfo(
            polyline: polyline,
            startFraction: startFraction,
            endFraction: endFraction,
            startColor: startColor,
            endColor: endColor
        ))
    }

    return polylines
}

// A function to simplify coordinates (implements the Ramer-Douglas-Peucker algorithm)
static func simplifyPolyline(_ coordinates: [CLLocationCoordinate2D], tolerance: Double) -> [CLLocationCoordinate2D] {
    // Return the coordinates as is if there are 2 or fewer points, or if the tolerance is less than 0
    guard coordinates.count > 2 else { return coordinates }
    guard tolerance >= 0 else { return coordinates }

    var result: [CLLocationCoordinate2D] = []
    var stack: [(startIndex: Int, endIndex: Int)] = [(0, coordinates.count - 1)]
    var include: [Bool] = Array(repeating: false, count: coordinates.count)

    include[0] = true
    include[coordinates.count - 1] = true

    // Process recursively using a stack
    while !stack.isEmpty {
        let (startIndex, endIndex) = stack.removeLast()
        let start = coordinates[startIndex]
        let end = coordinates[endIndex]

        var maxDistance: Double = 0
        var currentIndex: Int?

        // Find the farthest point from the current line
        for index in (startIndex + 1)..<endIndex {
            let distance = perpendicularDistance(point: coordinates[index], lineStart: start, lineEnd: end)
            if distance > maxDistance {
                maxDistance = distance
                currentIndex = index
            }
        }

        // If the farthest point exceeds the tolerance, include it and subdivide further
        if let currentIndex, maxDistance > tolerance {
            include[currentIndex] = true
            stack.append((startIndex, currentIndex))
            stack.append((currentIndex, endIndex))
        }
    }

    // Add only the coordinates where include is true to the result
    for (index, shouldInclude) in include.enumerated() where shouldInclude {
        result.append(coordinates[index])
    }

    return result
}

// A function to calculate the vertical distance between a point and a line
private static func perpendicularDistance(point: CLLocationCoordinate2D, lineStart: CLLocationCoordinate2D, lineEnd: CLLocationCoordinate2D) -> Double {
    let x0 = point.latitude
    let y0 = point.longitude
    let x1 = lineStart.latitude
    let y1 = lineStart.longitude
    let x2 = lineEnd.latitude
    let y2 = lineEnd.longitude

    // Distance formula (distance between a point and a line in a 2D plane)
    let numerator = abs((y2 - y1) * x0 - (x2 - x1) * y0 + x2 * y1 - y2 * x1)
    let denominator = sqrt(pow(y2 - y1, 2) + pow(x2 - x1, 2))

    // If the length of the line is 0, set the distance to 0
    return denominator != 0 ? numerator / denominator : 0
}