# server.R for EuroMeteo Explorer
# Helper function for label generation
generate_station_label <- function(name, id, country, start_date, end_date, detailed_summary, resolution_info, val = NULL, label_name = "Observation", unit = "", missing_label = NULL, missing_color = "#8A8F98") {
tryCatch(
{
val_html <- ""
if (!is.null(val) && !is.na(val)) {
# Determine color based on label_name
color <- if (grepl("Temperature", label_name, ignore.case = TRUE)) {
if (exists("temp_to_color")) temp_to_color(val) else "#0056b3"
} else if (grepl("Precipitation", label_name, ignore.case = TRUE)) {
if (exists("precip_to_color")) precip_to_color(val) else "#0056b3"
} else if (grepl("Pressure", label_name, ignore.case = TRUE)) {
if (exists("pressure_to_color")) pressure_to_color(val) else "#0056b3"
} else if (grepl("Wind Speed", label_name, ignore.case = TRUE)) {
if (exists("wind_speed_to_color")) wind_speed_to_color(val) else "#0056b3"
} else {
"#0056b3"
}
val_html <- paste0(
"",
"
", label_name, "
",
"
",
round(val, 1),
"", unit, "",
"
",
"
",
"
", label_name, "
",
"
",
htmltools::htmlEscape(missing_label),
"
",
"
",
# Header Section
"
",
"
", htmltools::htmlEscape(name), "
",
"
",
"", htmltools::htmlEscape(country), "",
"", id, "",
"
",
"
",
# Value Section (if available)
val_html,
# Parameters & Status Section
"
",
"
",
" Status & Capabilities",
"
",
"
",
resolution_info,
"
",
"
",
"
", htmltools::htmlEscape(name), "
(", id, ")
")
}
)
}
server <- function(input, output, session) {
# --- Reactive Values ---
current_station_id <- reactiveVal(NULL)
station_data <- reactiveVal(NULL) # The loaded data
loading_status <- reactiveVal(FALSE)
loading_diagnostics <- reactiveVal("")
map_fetch_token <- reactiveVal(0)
map_fetch_active <- reactiveVal(FALSE)
map_render_pending <- reactiveVal(FALSE)
map_render_token <- reactiveVal(NULL)
previous_station_choices <- reactiveVal(NULL) # Track previous choices to avoid blink
url_initialized <- reactiveVal(FALSE) # Track if URL params have been applied
current_resolution <- reactiveVal("Hourly") # Internal default resolution
# MapLibre Reactive Values
style_change_trigger <- reactiveVal(0) # Trigger station re-render after style change
map_initialized <- reactiveVal(FALSE) # Track if map bounds have been set
stations_before_id <- reactiveVal(NULL) # Layer ID for station ordering
current_raster_layers <- reactiveVal(character(0)) # Track dynamically added raster layers
basemap_debounced <- shiny::debounce(reactive(input$basemap), 200)
# Track last selected department to prevent auto-zoom on resolution change
last_dept <- reactiveVal("All")
# Map bounds for Europe (MeteoGate) - Broadened to zoom out one level
map_bounds <- list(
lat_min = 30.0,
lat_max = 75.0,
lng_min = -25.0,
lng_max = 55.0
)
station_internal_cols <- c(
"station_id", "station_name", "standard_name", "value", "param_name",
"level", "method", "period", "period_seconds", "method_rank", "level_rank",
"temp", "rh", "wind_dir", "pressure", "pressure_sea", "pressure_station", "precip", "solar_global", "dew_point"
)
get_station_display_cols <- function(df) {
all_cols <- names(df)
display_cols <- all_cols[!(all_cols %in% station_internal_cols)]
alias_map <- attr(df, "preferred_alias_map")
if (!is.null(alias_map) && length(alias_map) > 0) {
alias_names <- names(alias_map)
for (alias in alias_names) {
if (is.null(alias) || is.na(alias) || !nzchar(alias)) next
if (!(alias %in% display_cols)) next
variant_col <- alias_map[[alias]]
if (is.null(variant_col) || is.na(variant_col) || !nzchar(variant_col)) next
if (variant_col %in% display_cols && variant_col != alias) {
display_cols <- setdiff(display_cols, alias)
}
}
}
# Remove columns that are true value-duplicates over the current selection.
# Keep the one with the shortest name (usually the most general/clean one).
display_cols <- display_cols[order(nchar(display_cols))]
kept_cols <- character(0)
for (col in display_cols) {
if (col == "datetime") {
kept_cols <- c(kept_cols, col)
next
}
is_duplicate <- FALSE
for (prev_col in kept_cols) {
if (prev_col == "datetime") next
v1 <- df[[col]]
v2 <- df[[prev_col]]
if (length(v1) != length(v2)) next
same <- if (is.numeric(v1) && is.numeric(v2)) {
(is.na(v1) & is.na(v2)) | (!is.na(v1) & !is.na(v2) & abs(v1 - v2) <= 1e-9)
} else {
(is.na(v1) & is.na(v2)) | (!is.na(v1) & !is.na(v2) & as.character(v1) == as.character(v2))
}
if (all(same)) {
is_duplicate <- TRUE
break
}
}
if (!is_duplicate) {
kept_cols <- c(kept_cols, col)
}
}
# Restore original order but filter to kept ones
final_cols <- all_cols[all_cols %in% kept_cols]
display_cols <- final_cols[final_cols %in% display_cols]
# Apply custom weather column sorting (Grouping and Precipitation order)
display_cols <- sort_weather_columns(display_cols)
display_cols
}
format_wind_speed_decimals <- function(df, digits = 1) {
if (is.null(df) || nrow(df) == 0) {
return(df)
}
wind_cols <- names(df)[grepl("^(wind_speed|wind_gust|wind_speed_of_gust)", names(df))]
if (length(wind_cols) == 0) {
return(df)
}
for (col in wind_cols) {
if (is.numeric(df[[col]])) {
df[[col]] <- round(df[[col]], digits)
}
}
df
}
queue_map_render <- function(message = "Plotting stations...") {
if (!isTRUE(isolate(map_render_pending()))) {
return()
}
token <- isolate(map_render_token())
if (is.null(token)) {
map_render_pending(FALSE)
return()
}
session$sendCustomMessage("awaitMapRender", list(
mapId = "map",
token = token,
text = message
))
}
label_layer_ids <- c(
# OpenFreeMap Positron & Bright common labels
"waterway_line_label", "water_name_point_label", "water_name_line_label",
"highway-name-path", "highway-name-minor", "highway-name-major",
"highway-shield-non-us", "highway-shield-us-interstate", "road_shield_us",
"airport", "label_other", "label_village", "label_town", "label_state",
"label_city", "label_city_capital", "label_country_3", "label_country_2", "label_country_1",
# Bright specific labels (POIs & Directions)
"road_oneway", "road_oneway_opposite", "poi_r20", "poi_r7", "poi_r1", "poi_transit",
# Dash variants (sometimes used in different versions)
"waterway-line-label", "water-name-point-label", "water-name-line-label",
"highway-shield-non-us", "highway-shield-us-interstate", "road-shield-us",
"label-other", "label-village", "label-town", "label-state",
"label-city", "label-city-capital", "label-country-3", "label-country-2", "label-country-1",
# Legacy/Carto/OSM label names (for compatibility)
"place_villages", "place_town", "place_country_2", "place_country_1",
"place_state", "place_continent", "place_city_r6", "place_city_r5",
"place_city_dot_r7", "place_city_dot_r4", "place_city_dot_r2", "place_city_dot_z7",
"place_capital_dot_z7", "place_capital", "roadname_minor", "roadname_sec",
"roadname_pri", "roadname_major", "motorway_name", "watername_ocean",
"watername_sea", "watername_lake", "watername_lake_line", "poi_stadium",
"poi_park", "poi_zoo", "airport_label", "country-label", "state-label",
"settlement-major-label", "settlement-minor-label", "settlement-subdivision-label",
"road-label", "waterway-label", "natural-point-label", "poi-label", "airport-label"
)
# Layers to hide in Satellite (Hybrid) mode to let the raster shows through
# This includes all non-symbol layers (background, water, roads, boundaries, etc.)
non_label_layer_ids <- c(
"background", "park", "water", "landcover_ice_shelf", "landcover_glacier",
"landuse_residential", "landcover_wood", "waterway", "building",
"tunnel_motorway_casing", "tunnel_motorway_inner", "aeroway-taxiway",
"aeroway-runway-casing", "aeroway-area", "aeroway-runway",
"road_area_pier", "road_pier", "highway_path", "highway_minor",
"highway_major_casing", "highway_major_inner", "highway_major_subtle",
"highway_motorway_casing", "highway_motorway_inner", "highway_motorway_subtle",
"railway_transit", "railway_transit_dashline", "railway_service",
"railway_service_dashline", "railway", "railway_dashline",
"highway_motorway_bridge_casing", "highway_motorway_bridge_inner",
"boundary_3", "boundary_2", "boundary_disputed"
)
apply_label_visibility <- function(proxy, show_labels) {
visibility <- if (isTRUE(show_labels)) "visible" else "none"
for (layer_id in label_layer_ids) {
tryCatch(
{
proxy %>% set_layout_property(layer_id, "visibility", visibility)
},
error = function(e) {
# Layer may not exist in current style, ignore silently
}
)
}
}
# Helper: Parse URL query string
parse_url_params <- function(query_string) {
if (is.null(query_string) || query_string == "" || query_string == "?") {
return(list())
}
qs <- sub("^\\?", "", query_string)
if (qs == "") {
return(list())
}
pairs <- strsplit(qs, "&")[[1]]
params <- list()
for (pair in pairs) {
kv <- strsplit(pair, "=")[[1]]
if (length(kv) == 2) {
params[[kv[1]]] <- URLdecode(kv[2])
}
}
params
}
# Helper: Broadcast current state to parent page
broadcast_state <- function(view_override = NULL) {
# Get scalar values from current selection
sid <- current_station_id()
st_meta <- NULL
if (!is.null(sid)) {
# Use all_stations() to lookup metadata
# We use isolate to prevent cyclic dependencies if called from an observer
# asking for this data
all <- isolate(all_stations())
if (!is.null(all)) {
st_meta <- all %>% filter(id == sid)
}
}
station_id <- if (!is.null(st_meta) && nrow(st_meta) > 0) as.character(st_meta$id[1]) else NULL
station_name <- if (!is.null(st_meta) && nrow(st_meta) > 0) as.character(st_meta$name[1]) else NULL
s_country <- if (!is.null(st_meta) && nrow(st_meta) > 0) {
as.character(st_meta$country[1])
} else if (!is.null(input$country_selector) && length(input$country_selector) > 0 && !("All Countries" %in% input$country_selector)) {
paste(input$country_selector, collapse = ", ")
} else {
NULL
}
resolution <- current_resolution()
main_tab <- input$main_nav
view <- if (!is.null(view_override)) {
view_override
} else if (!is.null(main_tab)) {
if (main_tab == "Map View") {
"map"
} else if (main_tab == "Stations Info") {
"station-info"
} else if (main_tab == "Dashboard") {
subtab <- input$dashboard_subtabs
if (!is.null(subtab) && subtab == "Data") {
"dashboard-data"
} else {
"dashboard-plots"
}
} else {
"map"
}
} else {
"map"
}
session$sendCustomMessage("updateParentURL", list(
station = station_name, # Use Name instead of ID for URL
stationName = station_name,
country = s_country,
resolution = resolution,
view = view,
view = view,
parameter = input$map_parameter,
hours_ago = if (!is.null(input$time_slider)) input$time_slider else 0,
time_label = if (!is.null(input$time_slider)) {
target_time <- Sys.time() - (input$time_slider * 3600)
format(target_time, "%Y-%m-%d %H:00 UTC", tz = "UTC")
} else {
format(Sys.time(), "%Y-%m-%d %H:00 UTC", tz = "UTC")
}
))
# Update the URL in the address bar (for standalone usage)
hours_val <- if (!is.null(input$time_slider)) input$time_slider else 0
query_parts <- c()
if (!is.null(station_name)) query_parts <- c(query_parts, paste0("station=", URLencode(station_name)))
if (!is.null(s_country)) query_parts <- c(query_parts, paste0("country=", URLencode(s_country)))
query_parts <- c(
query_parts,
paste0("resolution=", URLencode(resolution)),
paste0("view=", URLencode(view)),
paste0("parameter=", URLencode(if (is.null(input$map_parameter)) "air_temperature" else input$map_parameter))
)
query_string <- paste0("?", paste(query_parts, collapse = "&"))
updateQueryString(query_string, mode = "push")
}
# Observer: Apply URL params on app startup
observe({
req(!url_initialized())
query <- session$clientData$url_search
params <- parse_url_params(query)
if (length(params) == 0) {
url_initialized(TRUE)
return()
}
# Apply resolution
if (!is.null(params$resolution) && params$resolution %in% c("Hourly", "Daily", "6-min", "Monthly")) {
current_resolution(params$resolution)
}
# Apply parameter
if (!is.null(params$parameter)) {
updateSelectInput(session, "map_parameter", selected = params$parameter)
}
# Apply hours_ago
if (!is.null(params$hours_ago)) {
val <- as.numeric(params$hours_ago)
if (!is.na(val) && val >= 0 && val <= 23) {
updateSliderInput(session, "time_slider", value = val)
}
}
# Apply date range - REMOVED for real-time focus
# Apply country filter from URL
if (!is.null(params$country)) {
shinyjs::delay(300, {
selected_country <- strsplit(params$country, ",")[[1]][1]
updateSelectizeInput(session, "country_selector", selected = trimws(selected_country))
})
}
# Apply station selection
if (!is.null(params$station)) {
station_ref <- params$station
# We need to wait for stations to be available
# We'll rely on the fact that existing observers handle ID updates
# Try to find station in all_stations and set it
# Defer slightly to ensure data is loaded
shinyjs::delay(500, {
st <- isolate(all_stations())
if (!is.null(st)) {
# Match by ID or Name
match <- st %>% filter(id == station_ref | name == station_ref)
if (nrow(match) > 0) {
target_id <- match$id[1]
current_station_id(target_id)
updateSelectizeInput(session, "station_selector", selected = target_id)
# Trigger fetch logic if needed, though observers on 'current_station_id' or input should handle
fetch_trigger(fetch_trigger() + 1)
}
}
})
}
# Apply view/tab navigation
if (!is.null(params$view)) {
view <- params$view
shinyjs::delay(800, {
if (view == "map") {
nav_select("main_nav", "Map View")
} else if (view == "station-info") {
nav_select("main_nav", "Stations Info")
} else if (view %in% c("dashboard-plots", "dashboard-data")) {
nav_select("main_nav", "Dashboard")
if (view == "dashboard-data") {
shinyjs::delay(200, {
# Robust switch to Data tab
shinyjs::runjs("$('#dashboard_subtabs a[data-value=\"Data\"]').tab('show');")
})
}
}
})
}
url_initialized(TRUE)
})
# Observer: Broadcast State Changes
observe({
input$station_selector
input$main_nav
input$dashboard_subtabs
current_station_id()
input$map_parameter
input$time_slider
input$country_selector
# Debounce slightly to avoid rapid-fire updates?
# Or just rely on reactive flush.
# Check initialization
req(url_initialized())
# Broadcast
broadcast_state()
})
# Default Date Range Init - REMOVED
current_index <- reactive({
NULL
})
all_stations <- reactive({
# Load MeteoGate Stations
get_meteogate_stations()
})
# --- Freeze UI During Data Loading ---
# Disable all interactive controls (except map hovering) while parsing data
observe({
is_loading <- loading_status()
# List of input IDs to disable/enable
inputs_to_toggle <- c(
"station_selector",
"country_selector",
"date_range",
"zoom_home",
"main_nav",
"download_hourly"
)
if (is_loading) {
for (inp in inputs_to_toggle) {
shinyjs::disable(inp)
}
} else {
for (inp in inputs_to_toggle) {
shinyjs::enable(inp)
}
}
})
# Initialize / Update Country Selector Choices based on Data Availability
observe({
st <- all_stations()
req(st)
# Get Current Observation Data to filter countries
obs <- viewport_obs_data()
# Calculate available countries
# If we have data, filter strictly to countries present in the data
# If data is NULL (loading/error), fall back to all countries to avoid empty list during transitions
country_list <- if (!is.null(obs) && nrow(obs) > 0) {
# Filter stations that have data
ids_with_data <- unique(obs$station_id)
visible_stations <- st %>% filter(id %in% ids_with_data)
sort(unique(visible_stations$country))
} else {
# Fallback
sort(unique(st$country))
}
# Add 'All Countries' as the first option
countries <- c("All Countries", country_list)
# Update input (preserve selection if possible)
# Use isolate() to avoid reactive dependency on the selector itself (prevents blink loop)
current_sel <- isolate(input$country_selector)
updateSelectizeInput(session, "country_selector", choices = countries, selected = current_sel, server = TRUE)
})
# Auto-Zoom on Country Selection (Zoom Only, No Filter)
observeEvent(input$country_selector,
{
req(all_stations())
# Use all_stations to calculate bounds for the selected countries
# We do NOT filter the main data, just finding the bounds to zoom to.
df <- all_stations()
if (!is.null(input$country_selector) && length(input$country_selector) > 0 && !("All Countries" %in% input$country_selector)) {
df_subset <- df %>% filter(country %in% input$country_selector)
if (nrow(df_subset) > 0) {
lons <- range(df_subset$longitude, na.rm = TRUE)
lats <- range(df_subset$latitude, na.rm = TRUE)
if (nrow(df_subset) == 1) {
maplibre_proxy("map") %>%
fly_to(center = c(df_subset$longitude[1], df_subset$latitude[1]), zoom = 12)
} else {
maplibre_proxy("map") %>%
fit_bounds(c(lons[1], lats[1], lons[2], lats[2]), animate = TRUE)
}
}
} else {
# All Countries -> Zoom to Default Bounds
maplibre_proxy("map") %>%
fit_bounds(
c(map_bounds$lng_min, map_bounds$lat_min, map_bounds$lng_max, map_bounds$lat_max),
animate = TRUE
)
}
},
ignoreInit = TRUE
)
# Filtered stations based on Sidebar inputs
filtered_stations <- reactive({
req(all_stations(), current_resolution())
df <- all_stations()
res <- tolower(current_resolution())
# Filter by Country - REMOVED (Zoom only)
# if (!is.null(input$country_selector) && length(input$country_selector) > 0) {
# df <- df %>% filter(country %in% input$country_selector)
# }
# 3. Create Dynamic Hover Info (Resolution + Period Aware)
# MeteoGate uses 'available_params' column
df <- df %>% mutate(
st_params = if ("available_params" %in% names(.)) available_params else NA_character_,
resolution_info = purrr::map2_chr(end_date, st_params, function(ed, p) {
p_text <- get_resolution_params(res, p)
paste0(
ifelse(as.Date(ed) >= Sys.Date() - 7, "Active Now", "Historical Data Only"),
"
Available:
", p_text
)
})
)
# Defensive: atomic data.frame to prevent tibble/rowwise issues
as.data.frame(df)
})
filtered_stations_sf <- reactive({
df <- filtered_stations()
req(df)
if (nrow(df) == 0) {
return(sf::st_as_sf(df, coords = c("longitude", "latitude"), crs = 4326, remove = FALSE))
}
sf::st_as_sf(df, coords = c("longitude", "latitude"), crs = 4326, remove = FALSE)
})
# Render Time Slider dynamically to ensure correct initial value
output$time_slider_ui <- renderUI({
# If minute < 30, data for current hour might not be ready, so default to 1 hour ago
initial_minute <- as.numeric(format(Sys.time(), "%M"))
initial_val <- if (initial_minute < 30) 1 else 0
sliderInput(
"time_slider",
label = NULL,
min = 0,
max = 23,
value = initial_val,
step = 1,
ticks = TRUE,
width = "100%"
)
})
# Initialize / Update Station Selector Choices
observe({
df <- filtered_stations()
req(df)
# Create choices: "Station Name (ID)" = "ID"
# Defensive: Ensure atomic vectors
ids <- as.character(df$id)
names <- paste0(as.character(df$name), " (", ids, ")")
if (length(ids) > 0) {
new_choices <- setNames(ids, names)
} else {
new_choices <- character(0)
}
# Only update if choices have actually changed (compare IDs)
prev_choices <- previous_station_choices()
new_ids <- sort(unname(new_choices))
prev_ids <- if (!is.null(prev_choices)) sort(unname(prev_choices)) else NULL
if (is.null(prev_ids) || !identical(new_ids, prev_ids)) {
# Preserve selection if still in filtered list
current_sel <- input$station_selector
updateSelectizeInput(session, "station_selector",
choices = new_choices,
selected = current_sel,
server = TRUE
)
previous_station_choices(new_choices)
}
})
# --- Selection Logic via Dropdown ---
observeEvent(input$station_selector, {
req(input$station_selector)
id_val <- input$station_selector
# Find station details
# Check filtered_stations first to get resolution_info
s_meta <- filtered_stations() %>% filter(id == id_val)
if (nrow(s_meta) == 0) {
# Fallback to all_stations if not in current filter
s_meta <- all_stations() %>% filter(id == id_val)
# Add dummy resolution_info if missing
if (!("resolution_info" %in% names(s_meta))) {
s_meta$resolution_info <- "Data status unavailable for current filter"
}
}
req(nrow(s_meta) > 0)
lat_val <- s_meta$latitude[1]
lng_val <- s_meta$longitude[1]
# Set ID
# Optimization: If ID is same as current, do not re-trigger date resets or map moves
# This prevents circular loops where Date Filter -> Filtered List -> Update Selector -> Trigger Observer -> Reset Date
prev_id <- current_station_id()
if (!is.null(prev_id) && prev_id == id_val) {
return()
}
current_station_id(id_val)
# Try to get temperature from view session
obs <- viewport_obs_data()
match <- if (!is.null(obs)) obs %>% filter(station_id == id_val) else NULL
current_temp <- if (!is.null(match) && nrow(match) > 0) match$temp[1] else NULL
current_param_name <- if (!is.null(match) && nrow(match) > 0 && "param_name" %in% names(match)) {
match$param_name[1]
} else {
NA_character_
}
# Generate label for highlight
current_param <- isolate(input$map_parameter)
if (is.null(current_param)) current_param <- "air_temperature"
param_label <- if (current_param == "precipitation_amount") "Precipitation" else "Air Temperature"
param_unit <- if (current_param == "precipitation_amount") "mm" else "°C"
missing_label <- if (current_param == "precipitation_amount") "No precip available at this hour" else NULL
res_info <- if ("resolution_info" %in% names(s_meta)) s_meta$resolution_info[1] else "Data status unavailable"
if (is.null(res_info) || is.na(res_info)) res_info <- "Data status unavailable for current filter"
label_name <- if (current_param == "precipitation_amount") {
format_precip_label(current_param_name, param_label)
} else {
param_label
}
lbl <- generate_station_label(
s_meta$name[1], s_meta$id[1], s_meta$country[1],
s_meta$start_date[1], s_meta$end_date[1], s_meta$detailed_summary[1],
res_info,
val = current_temp,
label_name = label_name,
unit = param_unit,
missing_label = missing_label
)
# Highlight & Zoom using helper
highlight_selected_station(maplibre_proxy("map"), lng_val, lat_val, lbl)
# NOTE: Date reset removed to preserve user context
})
start_map_fetch <- function(message) {
if (isTRUE(isolate(loading_status()))) {
return(NULL)
}
token <- isolate(map_fetch_token()) + 1
map_fetch_token(token)
map_fetch_active(TRUE)
map_render_pending(TRUE)
map_render_token(token)
session$sendCustomMessage("freezeUI", list(text = message, allowCancel = FALSE))
token
}
end_map_fetch <- function(token) {
if (is.null(token)) {
return()
}
if (isolate(map_fetch_token()) != token) {
return()
}
map_fetch_active(FALSE)
if (!isTRUE(isolate(loading_status())) && !isTRUE(isolate(map_render_pending()))) {
session$sendCustomMessage("unfreezeUI", list())
}
}
unfreeze_ui_if_idle <- function() {
if (!isTRUE(isolate(loading_status())) && !isTRUE(isolate(map_fetch_active())) && !isTRUE(isolate(map_render_pending()))) {
session$sendCustomMessage("unfreezeUI", list())
}
}
observeEvent(input$map_rendered,
{
req(input$map_rendered)
token <- suppressWarnings(as.numeric(input$map_rendered$token))
current_token <- isolate(map_render_token())
if (is.na(token) || is.null(current_token) || token != current_token) {
return()
}
map_render_pending(FALSE)
if (!isTRUE(isolate(loading_status())) && !isTRUE(isolate(map_fetch_active()))) {
session$sendCustomMessage("unfreezeUI", list())
}
},
ignoreInit = TRUE
)
# Viewport temperature data (shared by map + sidebar)
viewport_obs_data <- reactiveVal(NULL)
observe({
df <- filtered_stations()
req(df, current_resolution(), input$map_parameter, !is.null(input$time_slider))
hours_ago <- input$time_slider
# input$map_parameter already returns the value like "air_temperature" or "precipitation_amount"
param_slug <- input$map_parameter
selected_param_ui <- case_when(
param_slug == "air_temperature" ~ "Air Temperature",
param_slug == "precipitation_amount" ~ "Precipitation",
param_slug == "air_pressure_at_mean_sea_level" ~ "Sea Level Pressure",
param_slug == "wind_speed" ~ "Wind Speed",
TRUE ~ "Data"
)
# Calculate bounds from ALL filtered stations to prevent re-fetching/re-drawing on pan/zoom
# This renders all stations (approx 5000-6000), which is fine for MapLibre
if (nrow(df) > 0) {
lats <- range(df$latitude, na.rm = TRUE)
lons <- range(df$longitude, na.rm = TRUE)
# Add small buffer
bounds <- list(
lat_min = lats[1] - 0.1,
lat_max = lats[2] + 0.1,
lng_min = lons[1] - 0.1,
lng_max = lons[2] + 0.1
)
} else {
if (!isTRUE(map_initialized())) {
viewport_obs_data(NULL)
return()
}
bounds <- map_bounds
}
time_label <- if (hours_ago == 0) "current hour" else paste0(hours_ago, " hour(s) ago")
map_fetch_message <- paste0("Fetching map ", selected_param_ui, " (", time_label, ")...")
fetch_token <- start_map_fetch(map_fetch_message)
if (is.null(fetch_token)) {
return()
}
current_session <- shiny::getDefaultReactiveDomain()
later::later(function() {
shiny::withReactiveDomain(current_session, {
if (isolate(map_fetch_token()) != fetch_token) {
return()
}
result <- tryCatch(
get_observations_for_viewport(
zoom = 10, # Force high zoom logic (no decimation)
bounds = bounds,
hours_ago = hours_ago,
stations = df,
param_name = param_slug
),
error = function(e) NULL
)
if (isolate(map_fetch_token()) != fetch_token) {
return()
}
viewport_obs_data(result)
end_map_fetch(fetch_token)
})
}, delay = 0.05)
})
# Station Count
output$station_count_filtered <- renderText({
n <- nrow(filtered_stations())
paste(n, "stations found")
})
# Temperature data info
output$temp_data_info <- renderUI({
hours_ago <- if (!is.null(input$time_slider)) input$time_slider else return(NULL)
obs_data <- viewport_obs_data()
if (is.null(obs_data) || nrow(obs_data) == 0) {
return(tags$small(style = "color: #888;", "No temperature data available in view"))
}
# Get the average observation time for this hour
avg_time <- mean(obs_data$datetime, na.rm = TRUE)
time_str <- format(avg_time, "%Y-%m-%d %H:%M UTC")
div(
style = "font-size: 0.85em; color: #555; margin-top: 5px;",
tags$span(
style = "display: flex; align-items: center; gap: 5px;",
bsicons::bs_icon("thermometer-half", size = "1em"),
paste0("Showing: ", nrow(obs_data), " stations")
),
div(style = "margin-left: 20px; font-weight: 500;", time_str),
tags$small(
style = "color: #888;",
if (hours_ago == 0) "Current observations" else paste0(hours_ago, " hour(s) ago")
)
)
})
# Time slider label
output$selected_time_label <- renderText({
hours_ago <- if (!is.null(input$time_slider)) input$time_slider else return("")
target_time <- Sys.time() - (hours_ago * 3600)
format(target_time, "%Y-%m-%d %H:00 UTC", tz = "UTC")
})
# --- Map ---
output$map <- renderMaplibre({
maplibre(
style = "https://tiles.openfreemap.org/styles/positron",
center = c(10, 50),
zoom = 4
) %>%
add_navigation_control(show_compass = FALSE, visualize_pitch = FALSE, position = "top-left")
})
# Initialize map bounds only once
observe({
req(!map_initialized())
req(input$map_zoom)
maplibre_proxy("map") %>%
fit_bounds(
c(map_bounds$lng_min, map_bounds$lat_min, map_bounds$lng_max, map_bounds$lat_max)
)
map_initialized(TRUE)
})
# Zoom to extent of all filtered stations
observeEvent(input$zoom_home, {
df <- filtered_stations()
req(df)
if (nrow(df) > 0) {
# Calculate bounds
lons <- range(df$longitude, na.rm = TRUE)
lats <- range(df$latitude, na.rm = TRUE)
# Calculate geographic extent
lon_span <- lons[2] - lons[1]
lat_span <- lats[2] - lats[1]
# If only one station, zoom to it with a small buffer
if (nrow(df) == 1) {
maplibre_proxy("map") %>%
fly_to(center = c(df$longitude[1], df$latitude[1]), zoom = 12)
} else if (lon_span > 60 || lat_span > 40) {
# Stations are globally distributed (former colonies) - use world view
# Center on France but zoom out to see the whole world
maplibre_proxy("map") %>%
fly_to(center = c(2.2137, 20), zoom = 2)
} else {
maplibre_proxy("map") %>%
fit_bounds(c(lons[1], lats[1], lons[2], lats[2]), animate = TRUE)
}
}
})
# Fix Map Rendering on Tab Switch
observeEvent(input$main_nav, {
if (input$main_nav == "Map View") {
# Slight delay to ensure tab is visible - MapLibre handles resize automatically
shinyjs::runjs("
setTimeout(function() {
var map = document.getElementById('map');
if (map && map.__mapgl) {
map.__mapgl.resize();
}
}, 200);
")
}
})
# --- Basemap Switching ---
observeEvent(basemap_debounced(), {
basemap <- basemap_debounced()
proxy <- maplibre_proxy("map")
if (basemap %in% c("ofm_positron", "ofm_bright")) {
# VECTOR LOGIC (OpenFreeMap styles)
style_url <- switch(basemap,
"ofm_positron" = "https://tiles.openfreemap.org/styles/positron",
"ofm_bright" = "https://tiles.openfreemap.org/styles/bright"
)
proxy %>%
set_style(style_url, preserve_layers = FALSE)
# For OpenFreeMap sandwich, we want stations below labels
stations_before_id("waterway_line_label")
current_session <- shiny::getDefaultReactiveDomain()
selected_basemap <- basemap
later::later(function() {
shiny::withReactiveDomain(current_session, {
# Race condition check
current_basemap <- isolate(input$basemap)
if (current_basemap != selected_basemap) {
return()
}
# Trigger re-render of stations and apply label visibility
apply_label_visibility(maplibre_proxy("map"), isolate(input$show_labels))
style_change_trigger(isolate(style_change_trigger()) + 1)
})
}, delay = 0.35)
} else if (basemap == "sentinel") {
# HYBRID LOGIC (EOX Sentinel-2 Satellite + OpenFreeMap Labels/Roads)
# Use Positron as the base for labels/roads
proxy %>%
set_style(ofm_positron_style, preserve_layers = FALSE)
current_session <- shiny::getDefaultReactiveDomain()
selected_basemap <- basemap
later::later(function() {
shiny::withReactiveDomain(current_session, {
current_basemap <- isolate(input$basemap)
if (current_basemap != selected_basemap) {
return()
}
unique_suffix <- as.numeric(Sys.time()) * 1000
source_id <- paste0("sentinel_source_", unique_suffix)
layer_id <- paste0("sentinel_layer_", unique_suffix)
# Add Sentinel layer at the very bottom (before 'background')
# Actually, we'll hide background and put it just above it if needed,
# but 'background' is typically the absolute first.
maplibre_proxy("map") %>%
add_raster_source(id = source_id, tiles = c(sentinel_url), tileSize = 256, attribution = sentinel_attribution) %>%
add_layer(
id = layer_id,
type = "raster",
source = source_id,
paint = list("raster-opacity" = 1),
before_id = "background"
)
# Hide all non-label vector layers so only satellite + symbols show
for (layer_id_kill in non_label_layer_ids) {
tryCatch(
{
maplibre_proxy("map") %>% set_layout_property(layer_id_kill, "visibility", "none")
},
error = function(e) {
# Layer might not exist, ignore
}
)
}
# Ensure labels according to user preference
apply_label_visibility(maplibre_proxy("map"), isolate(input$show_labels))
# Stations should be above the satellite layer
# In Positron, waterway_line_label is the lowest symbol.
# Our stations are already set to render before waterway_line_label if the ID exists.
stations_before_id("waterway_line_label")
style_change_trigger(isolate(style_change_trigger()) + 1)
})
}, delay = 0.5)
}
})
# Toggle Labels visibility
observeEvent(input$show_labels,
{
apply_label_visibility(maplibre_proxy("map"), input$show_labels)
},
ignoreInit = TRUE
)
observeEvent(current_resolution(),
{
station_data(NULL)
parsed_data_list(list())
# Only block UI if we have a station selected (fetch will occur)
if (!is.null(current_station_id())) {
loading_status(TRUE)
}
},
priority = 1000,
ignoreInit = TRUE
)
# Update Markers
observe({
df <- filtered_stations_sf()
req(df, current_resolution())
# Wait for map to be ready before adding markers
req(map_initialized())
# Add dependency on style_change_trigger to re-add layer after style change
style_change_trigger()
# Get current parameter for labels/filters
current_param <- isolate(input$map_parameter)
if (is.null(current_param)) current_param <- "air_temperature"
is_precip <- current_param == "precipitation_amount"
is_pressure <- current_param == "air_pressure_at_mean_sea_level"
is_wind <- current_param == "wind_speed"
is_wind <- current_param == "wind_speed"
param_label <- case_when(
is_precip ~ "Precipitation",
is_pressure ~ "Sea Level Pressure",
is_wind ~ "Wind Speed",
TRUE ~ "Air Temperature"
)
param_unit <- case_when(
is_precip ~ "mm",
is_pressure ~ "hPa",
is_wind ~ "m/s",
TRUE ~ "°C"
)
missing_label <- case_when(
is_precip ~ "No precip available at this hour",
is_pressure ~ "No pressure available",
is_wind ~ "No wind available",
TRUE ~ NA_character_
)
# Fetch observations for the selected hour with zoom-based sampling
obs_data <- viewport_obs_data()
if (!is.null(obs_data) && nrow(obs_data) > 0) {
# Merge temperature data with stations
df <- df %>%
left_join(obs_data, by = c("id" = "station_id"))
if (!"param_name" %in% names(df)) {
df$param_name <- NA_character_
}
} else {
df$temp <- NA_real_
df$param_name <- NA_character_
if (!is_precip) {
# If no observations available for temperature, show nothing
maplibre_proxy("map") %>% clear_layer("stations")
queue_map_render()
return()
}
}
if (!is_precip) {
# Filter to only stations with temperature data
df <- df %>% filter(!is.na(temp))
}
if (nrow(df) == 0) {
maplibre_proxy("map") %>% clear_layer("stations")
queue_map_render()
return()
}
if (is_precip) {
df <- df %>% mutate(label_name = format_precip_label(param_name, param_label))
} else {
df$label_name <- param_label
}
use_detailed_tooltips <- isTRUE(input$detailed_tooltips)
if (use_detailed_tooltips) {
# Full hover cards (slower)
df <- df %>% mutate(
tooltip_content = purrr::pmap_chr(
list(name, id, country, start_date, end_date, detailed_summary, resolution_info, temp, label_name),
function(name, id, country, start_date, end_date, detailed_summary, resolution_info, val, label_name) {
generate_station_label(name, id, country, start_date, end_date, detailed_summary, resolution_info,
val = val, label_name = label_name, unit = param_unit, missing_label = missing_label
)
}
)
)
} else {
# Lightweight hover cards for faster rendering
label_name_vec <- df$label_name
value_text <- if (is_precip) {
fallback_text <- if (!is.null(missing_label) && !is.na(missing_label)) missing_label else "No data"
ifelse(!is.na(df$temp), paste0(round(df$temp, 1), " ", param_unit), fallback_text)
} else {
paste0(round(df$temp, 1), " ", param_unit)
}
df$tooltip_content <- paste0(
"",
"
", htmltools::htmlEscape(df$name), "
",
"
", htmltools::htmlEscape(df$country), "
",
"
",
htmltools::htmlEscape(label_name_vec), ": ", htmltools::htmlEscape(value_text),
"
",
"