library(dplyr)
library(osmdata)
library(terra)

cache_file <- "blog/posts/2026-09-29-nurburgring-in-3d-with-rayshader/data/nurburgring-3d.rds"
cache_version <- 2L

terrain_data <- if (file.exists(cache_file)) readRDS(cache_file) else NULL
cache_is_current <- !is.null(terrain_data$cache_version) &&
  terrain_data$cache_version == cache_version

if (!cache_is_current) {
  # Query ways only: nodes and relations are not used for the circuit line.
  raceway_query <- osmdata::opq(
    bbox = search_bbox_wgs84,
    osm_types = "way",
    timeout = 180
  ) |>
    osmdata::add_osm_feature(key = "highway", value = "raceway")

  # Overpass is public infrastructure, so retry a small set of global mirrors.
  download_raceways <- function(query) {
    overpass_urls <- c(
      "https://overpass.kumi.systems/api/interpreter",
      "https://overpass-api.de/api/interpreter",
      "https://api.openstreetmap.fr/oapi/interpreter"
    )
    original_url <- osmdata::get_overpass_url()
    on.exit(osmdata::set_overpass_url(original_url), add = TRUE)
    errors <- character()

    for (overpass_url in overpass_urls) {
      osmdata::set_overpass_url(overpass_url)
      message("Requesting raceway data from ", overpass_url, "...")
      response <- tryCatch(
        osmdata::osmdata_sf(query, quiet = TRUE),
        error = function(error) error
      )

      if (!inherits(response, "error")) {
        return(response)
      }

      errors <- c(errors, conditionMessage(response))
    }

    stop(
      "All selected Overpass mirrors failed. Try rendering again later. Last error: ",
      tail(errors, 1)
    )
  }

  track <- download_raceways(raceway_query)$osm_lines |>
    filter(highway == "raceway") |>
    select(osm_id, name, geometry) |>
    sf::st_transform(25832) |>
    sf::st_intersection(search_frame_utm)

  if (nrow(track) == 0) {
    stop("No raceway geometry found around the Nürburgring search area.")
  }

  # Expand the circuit bounds, adjusting the shorter side to the output ratio.
  track_bbox <- sf::st_bbox(track)
  frame_width_m <- (track_bbox[["xmax"]] - track_bbox[["xmin"]]) *
    (1 + terrain_margin_pct / 100)
  frame_height_m <- (track_bbox[["ymax"]] - track_bbox[["ymin"]]) *
    (1 + terrain_margin_pct / 100)

  if (frame_width_m / frame_height_m < screen_ratio) {
    frame_width_m <- frame_height_m * screen_ratio
  } else {
    frame_height_m <- frame_width_m / screen_ratio
  }

  track_centre <- c(
    mean(track_bbox[c("xmin", "xmax")]),
    mean(track_bbox[c("ymin", "ymax")])
  )

  terrain_frame_utm <- sf::st_bbox(
    c(
      xmin = track_centre[[1]] - frame_width_m / 2,
      ymin = track_centre[[2]] - frame_height_m / 2,
      xmax = track_centre[[1]] + frame_width_m / 2,
      ymax = track_centre[[2]] + frame_height_m / 2
    ),
    crs = sf::st_crs(25832)
  ) |>
    sf::st_as_sfc()

  terrain_bbox_wgs84 <- terrain_frame_utm |>
    sf::st_transform(4326) |>
    sf::st_bbox()

  # elevatr needs two corners to identify the terrain tiles covering the frame.
  elev_locations <- data.frame(
    x = c(terrain_bbox_wgs84[["xmin"]], terrain_bbox_wgs84[["xmax"]]),
    y = c(terrain_bbox_wgs84[["ymin"]], terrain_bbox_wgs84[["ymax"]])
  )

  dem <- elevatr::get_elev_raster(
    locations = elev_locations,
    z = 13,
    prj = "EPSG:4326",
    src = "aws",
    verbose = TRUE
  ) |>
    terra::rast() |>
    terra::project("EPSG:25832", method = "bilinear")

  # Cropping after projection makes the saved terrain match the circuit frame.
  dem <- terra::crop(dem, terra::ext(terra::vect(terrain_frame_utm)))
  elevation <- rayshader::raster_to_matrix(dem)
  terrain_extent <- as.vector(terra::ext(dem))
  names(terrain_extent) <- c("xmin", "xmax", "ymin", "ymax")

  dir.create(dirname(cache_file), recursive = TRUE, showWarnings = FALSE)
  saveRDS(
    list(
      cache_version = cache_version,
      track = track,
      elevation = elevation,
      extent = terrain_extent,
      resolution_m = mean(terra::res(dem))
    ),
    cache_file
  )

  terrain_data <- readRDS(cache_file)
}

track <- terrain_data$track
elevation <- terrain_data$elevation
terrain_extent <- terrain_data$extent
resolution_m <- terrain_data$resolution_m

# The overlay generator expects individual LINESTRING geometries.
track_paths <- track |>
  sf::st_cast("LINESTRING", warn = FALSE)