ezu-cli 0.12.0

//! axum handlers for `ezu serve`.

use std::sync::Arc;

use axum::{
    body::Body,
    extract::{Path, Query, State},
    http::{header, StatusCode},
    response::{
        sse::{Event, KeepAlive, Sse},
        Html, Response,
    },
    routing::get,
    Json, Router,
};
use ezu::core::TileId as CoreTileId;
use ezu::features::mvt;
use ezu::graph::{CanvasInfo, Evaluator, ParamValues, PortValue, TileId};
use ezu::paint::host::{
    bind_dem_sources, bind_geojson_sources, bind_raster_sources, raster_to_png, raster_to_webp,
    requested_neighbor_offsets, BrushBankLoader, DemFetchError, DemSourceRegistry, GeoJsonSources,
    RasterFetchError, RasterSourceRegistry, TileLoader,
};
use futures::stream::{self, Stream};
use serde_json::json;
use std::collections::HashMap;
use std::time::Duration;
use tokio::sync::broadcast;

use super::state::{validate_text, AppState, StyleSnapshot};
use crate::source::FeatureSource;

/// One feature source's bytes for a tile: its name, the centre tile, and
/// the neighbours the graph asks for, each with the tile they came from.
type FetchedMvt = (
    Arc<str>,
    Option<(bytes::Bytes, CoreTileId)>,
    Vec<((i32, i32), (bytes::Bytes, CoreTileId))>,
);

pub fn router() -> Router<AppState> {
    Router::new()
        .route("/", get(index))
        .route("/style", get(get_style).put(put_style))
        .route("/style/params", get(get_params_schema))
        .route("/style/attribution", get(get_attribution))
        .route("/config", get(get_config))
        .route("/style/validate", axum::routing::post(post_validate))
        .route("/style/fetch", get(get_style_fetch))
        .route("/style/events", get(get_style_events))
        .route("/schemas/ezu-style.json", get(get_schema))
        .route("/tiles/{z}/{x}/{y_ext}", get(get_tile))
        .route("/mvt/{z}/{x}/{y}", get(get_mvt))
        .route("/mvt-meta/{z}/{x}/{y}", get(get_mvt_meta))
}

async fn index() -> Html<&'static str> {
    Html(include_str!("editor.html"))
}

/// Zoom the editor should stop requesting tiles at when the source
/// declares its own depth. A source that stays quiet about it (a bare
/// `{z}/{x}/{y}` template) gets [`ABSOLUTE_MAXZOOM`] instead — the
/// renderer is happy to draw whatever the fetcher hands it, so an
/// unknown depth is no reason to fence the map in.
const ABSOLUTE_MAXZOOM: u8 = 22;

/// Server-side knobs the editor needs to configure its map. Kept as one
/// endpoint so the front end never has to guess at CLI defaults.
async fn get_config(State(s): State<AppState>) -> Json<serde_json::Value> {
    // The deepest any source goes, when every one of them says.
    let data_maxzoom = s
        .feature_sources
        .iter()
        .map(|src| src.max_zoom())
        .collect::<Option<Vec<u8>>>()
        .and_then(|zooms| zooms.into_iter().max());
    // Past the source's own depth the tile handler reprojects ancestor
    // tiles, `overzoom_levels` of them, so that is exactly how much
    // deeper than the data the editor can still ask for.
    let raster_maxzoom = match data_maxzoom {
        Some(z) => z.saturating_add(s.overzoom_levels).min(ABSOLUTE_MAXZOOM),
        None => ABSOLUTE_MAXZOOM,
    };
    Json(serde_json::json!({
        "overzoomLevels": s.overzoom_levels,
        "dataMaxzoom": data_maxzoom,
        "rasterMaxzoom": raster_maxzoom,
    }))
}

async fn get_style(State(s): State<AppState>) -> Response {
    let snap = s.style.read().await;
    Response::builder()
        .header(header::CONTENT_TYPE, "application/json; charset=utf-8")
        .header(header::CACHE_CONTROL, "no-store")
        .body(Body::from(snap.text.clone()))
        .expect("response builder with valid headers + body never fails")
}

async fn put_style(
    State(s): State<AppState>,
    body: String,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
    let next_version = { s.style.read().await.version + 1 };
    let snap = StyleSnapshot::build(body, next_version, &s.assets_dir)
        .await
        .map_err(|e| (StatusCode::BAD_REQUEST, e.to_string()))?;
    let version = snap.version;
    *s.style.write().await = snap;
    Ok(Json(json!({ "version": version })))
}

/// JSON Schema for the current style's parameter values — what the
/// tile endpoint accepts as query-string overrides. Editor UIs can
/// build sliders / color pickers / toggles straight off this.
async fn get_params_schema(State(s): State<AppState>) -> Json<serde_json::Value> {
    let snap = s.style.read().await;
    Json(snap.doc.params_schema())
}

/// Effective attribution for the current style: the document's own
/// declarations merged with upstream metadata (TileJSON `attribution`,
/// PMTiles archive metadata) inherited by sources that declare none.
/// The editor feeds this to the MapLibre attribution control.
async fn get_attribution(State(s): State<AppState>) -> Json<serde_json::Value> {
    let snap = s.style.read().await;
    let mut list: Vec<String> = snap
        .doc
        .attributions()
        .iter()
        .map(|a| a.to_string())
        .collect();
    let mut push = |a: String| {
        if !a.is_empty() && !list.contains(&a) {
            list.push(a);
        }
    };
    for a in snap
        .dem_sources
        .resolve_metadata()
        .await
        .unwrap_or_default()
    {
        push(a);
    }
    for a in snap
        .raster_sources
        .resolve_metadata()
        .await
        .unwrap_or_default()
    {
        push(a);
    }
    // Each MVT/PMTiles feature source inherits upstream metadata only
    // when the document's own entry doesn't declare attribution.
    for src in s.feature_sources.iter() {
        let declares = snap
            .doc
            .sources
            .get(&*src.name)
            .is_some_and(|d| d.attribution().is_some());
        if !declares {
            if let Some(a) = src.attribution() {
                push(a.to_string());
            }
        }
    }
    Json(json!({ "attributions": list, "attribution": list.join(" | ") }))
}

/// Dry-run the parse + graph-build pipeline `PUT /style` would run,
/// without prefetching URL assets or swapping the live snapshot. The
/// live editor pings this on every keystroke (debounced), so it has
/// to be cheap.
async fn post_validate(body: String) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
    validate_text(&body).map_err(|e| (StatusCode::BAD_REQUEST, e.to_string()))?;
    Ok(Json(json!({ "ok": true })))
}

/// Fetch a remote style document on behalf of the editor. Limited to
/// http(s) URLs so this can't be coaxed into serving arbitrary local
/// files via the browser. Used by the "Open URL" button.
async fn get_style_fetch(
    Query(q): Query<HashMap<String, String>>,
) -> Result<Response, (StatusCode, String)> {
    let url = q.get("url").ok_or((
        StatusCode::BAD_REQUEST,
        "missing url query parameter".into(),
    ))?;
    if !(url.starts_with("http://") || url.starts_with("https://")) {
        return Err((
            StatusCode::BAD_REQUEST,
            "only http(s) URLs are allowed".into(),
        ));
    }
    let text = crate::fetch_text(url)
        .await
        .map_err(|e| (StatusCode::BAD_GATEWAY, e.to_string()))?;
    Ok(Response::builder()
        .header(header::CONTENT_TYPE, "application/json; charset=utf-8")
        .header(header::CACHE_CONTROL, "no-store")
        .body(Body::from(text))
        .expect("response builder with valid headers + body never fails"))
}

/// Server-Sent Events stream of style-reload notifications. Fires
/// whenever the local style file watched by `ezu serve <file>` changes
/// on disk and the server successfully rebuilt the snapshot. The
/// editor listens to this and either silently swaps the buffer (clean
/// editor) or surfaces a banner (when the user has unsaved edits).
async fn get_style_events(
    State(s): State<AppState>,
) -> Sse<impl Stream<Item = Result<Event, std::convert::Infallible>>> {
    let rx = s.events.subscribe();
    let stream = stream::unfold(rx, |mut rx| async move {
        loop {
            match rx.recv().await {
                Ok(ev) => {
                    let event = Event::default()
                        .event("reload")
                        .json_data(&ev)
                        .unwrap_or_else(|_| Event::default());
                    return Some((Ok(event), rx));
                }
                // Skip lagged events; an editor missing a couple of
                // mid-flight reloads just sees the latest one next.
                Err(broadcast::error::RecvError::Lagged(_)) => continue,
                Err(broadcast::error::RecvError::Closed) => return None,
            }
        }
    });
    Sse::new(stream).keep_alive(KeepAlive::new().interval(Duration::from_secs(15)))
}

async fn get_schema(State(s): State<AppState>) -> Response {
    // Schema is derived from the live node registry so it always matches
    // the ops the server can actually evaluate.
    let body = serde_json::to_vec_pretty(&*s.schema).unwrap_or_default();
    Response::builder()
        .header(header::CONTENT_TYPE, "application/schema+json")
        .header(header::CACHE_CONTROL, "no-store")
        .body(Body::from(body))
        .expect("response builder with valid headers + body never fails")
}

#[derive(Clone, Copy)]
enum TileFormat {
    Png,
    Webp,
}

impl TileFormat {
    fn content_type(self) -> &'static str {
        match self {
            TileFormat::Png => "image/png",
            TileFormat::Webp => "image/webp",
        }
    }
}

async fn get_tile(
    State(s): State<AppState>,
    Path((z, x, y_ext)): Path<(u8, u32, String)>,
    Query(q): Query<HashMap<String, String>>,
) -> Result<Response, (StatusCode, String)> {
    // Sniff the output format off the extension. Default is PNG so the
    // legacy `/tiles/{z}/{x}/{y}` (no suffix) and `.png` keep working.
    let (y_str, format) = if let Some(s) = y_ext.strip_suffix(".webp") {
        (s, TileFormat::Webp)
    } else if let Some(s) = y_ext.strip_suffix(".png") {
        (s, TileFormat::Png)
    } else {
        (y_ext.as_str(), TileFormat::Png)
    };
    let y: u32 = y_str
        .parse()
        .map_err(|_| (StatusCode::BAD_REQUEST, "bad y".into()))?;
    let tile = CoreTileId::new(z, x, y);

    // Take only what we need from the snapshot to keep the lock window
    // short. Query-string parameter overrides are validated against
    // the document's `params` declarations while we hold the lock.
    let (
        graph,
        cache,
        assets,
        dem_sources,
        raster_sources,
        geojson_sources,
        tile_size,
        pad,
        params,
    ) = {
        let snap = s.style.read().await;
        let mut params = ParamValues::new();
        for (name, raw) in &q {
            // `v` is reserved as the editor's cache-busting version key.
            if name == "v" {
                continue;
            }
            let v = ezu::graph::parse_param_value(&snap.doc.params, name, raw)
                .map_err(|e| (StatusCode::BAD_REQUEST, e))?;
            params.set(name.clone(), v);
        }
        (
            Arc::clone(&snap.graph),
            Arc::clone(&snap.cache),
            Arc::clone(&snap.assets),
            Arc::clone(&snap.dem_sources),
            Arc::clone(&snap.raster_sources),
            Arc::clone(&snap.geojson_sources),
            snap.doc.tile_size,
            snap.pad,
            params,
        )
    };

    // Every feature source, each at its own zoom. Cross-tile placement
    // (label collision) adds only the neighbour tiles the graph asks for
    // via `@dx,dy` binding names — never the whole 3×3 window
    // unconditionally. Reuses the MVT cache per tile.
    let mut fetched_mvt: Vec<FetchedMvt> = Vec::new();
    let asset_inputs = graph.asset_inputs();
    for src in s.feature_sources.iter() {
        let centre = fetch_mvt(&s, src, tile).await?;
        let mut neighbours = Vec::new();
        let world = 1i64 << tile.z;
        for (dx, dy) in requested_neighbor_offsets(&asset_inputs, &src.name) {
            let ny = tile.y as i64 + dy as i64;
            if ny < 0 || ny >= world {
                continue;
            }
            let nx = (tile.x as i64 + dx as i64).rem_euclid(world) as u32;
            if let Some(hit) = fetch_mvt(&s, src, CoreTileId::new(tile.z, nx, ny as u32)).await? {
                neighbours.push(((dx, dy), hit));
            }
        }
        fetched_mvt.push((Arc::clone(&src.name), centre, neighbours));
    }

    let canvas = CanvasInfo::square(tile_size, pad);
    let tile_id = TileId {
        z: tile.z,
        x: tile.x,
        y: tile.y,
    };
    let dem_bindings = fetch_dem_bindings(&dem_sources, tile_id, canvas)
        .await
        .map_err(dem_fetch_status)?;
    let raster_bindings = fetch_raster_bindings(&raster_sources, tile_id, canvas)
        .await
        .map_err(raster_fetch_status)?;

    let bytes = tokio::task::spawn_blocking({
        move || {
            render_tile(
                &graph,
                &cache,
                &assets,
                fetched_mvt,
                dem_bindings,
                raster_bindings,
                &geojson_sources,
                tile,
                tile_size,
                pad,
                format,
                &params,
            )
        }
    })
    .await
    .map_err(|e| {
        tracing::error!("tile {z}/{x}/{} render task panicked: {e}", tile.y);
        (StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
    })?
    .map_err(|e| {
        tracing::error!("tile {z}/{x}/{}: {e}", tile.y);
        (StatusCode::INTERNAL_SERVER_ERROR, e)
    })?;

    Ok(Response::builder()
        .header(header::CONTENT_TYPE, format.content_type())
        .header(header::CACHE_CONTROL, "no-store")
        .body(Body::from(bytes))
        .expect("response builder with valid headers + body never fails"))
}

/// The feature source a raw-MVT request names with `?source=`, or the
/// style's first one.
fn requested_source<'s>(
    s: &'s AppState,
    q: &HashMap<String, String>,
) -> Result<Option<&'s FeatureSource>, (StatusCode, String)> {
    match q.get("source") {
        Some(name) => s
            .feature_sources
            .get(Some(name))
            .map(Some)
            .ok_or((StatusCode::NOT_FOUND, format!("no feature source `{name}`"))),
        None => Ok(s.feature_sources.get(None)),
    }
}

/// Return raw decompressed MVT bytes for `(z, x, y)` from the feature
/// source named by `?source=` (default: the first). Used by the WASM demo,
/// which does its own decoding + rendering client-side.
async fn get_mvt(
    State(s): State<AppState>,
    Path((z, x, y)): Path<(u8, u32, u32)>,
    Query(q): Query<HashMap<String, String>>,
) -> Result<Response, (StatusCode, String)> {
    let tile = CoreTileId::new(z, x, y);
    let Some(source) = requested_source(&s, &q)? else {
        return Err((StatusCode::NOT_FOUND, "tile not in source".into()));
    };
    // This endpoint serves native MVT bytes that callers expect to
    // decode at the requested tile's coordinate frame, so a parent
    // fallback (different coords) would be wrong. Treat overzoom hits
    // as misses here.
    let Some((bytes, src)) = fetch_mvt(&s, source, tile).await? else {
        return Err((StatusCode::NOT_FOUND, "tile not in source".into()));
    };
    if src != tile {
        return Err((StatusCode::NOT_FOUND, "tile not in source".into()));
    }
    Ok(Response::builder()
        .header(header::CONTENT_TYPE, "application/vnd.mapbox-vector-tile")
        .header(header::CACHE_CONTROL, "public, max-age=300")
        .body(Body::from(bytes.to_vec()))
        .expect("response builder with valid headers + body never fails"))
}

/// Decode the MVT for `(z, x, y)` and report which layers it contains.
/// Used by the editor's inspect panel to populate per-layer toggles
/// without having to re-decode MVTs in the browser.
async fn get_mvt_meta(
    State(s): State<AppState>,
    Path((z, x, y)): Path<(u8, u32, u32)>,
    Query(q): Query<HashMap<String, String>>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
    let tile = CoreTileId::new(z, x, y);
    let Some(source) = requested_source(&s, &q)? else {
        return Ok(Json(json!({ "layers": [] })));
    };
    // Layer names + geometry kinds don't change under overzoom, so it's
    // fine if the bytes came from an ancestor — no clipping needed.
    let Some((bytes, _src)) = fetch_mvt(&s, source, tile).await? else {
        return Ok(Json(json!({ "layers": [] })));
    };
    let decoded =
        mvt::decode(&bytes).map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
    let layers: Vec<_> = decoded
        .layers
        .iter()
        .map(|l| {
            let (mut p, mut ln, mut pg) = (false, false, false);
            for f in &l.features {
                if !f.geometry.points.is_empty() {
                    p = true;
                }
                if !f.geometry.lines.is_empty() {
                    ln = true;
                }
                if !f.geometry.polygons.is_empty() {
                    pg = true;
                }
            }
            let mut geoms: Vec<&str> = Vec::new();
            if p {
                geoms.push("point");
            }
            if ln {
                geoms.push("line");
            }
            if pg {
                geoms.push("polygon");
            }
            json!({
                "name": l.name,
                "geometry_types": geoms,
                "features": l.features.len(),
            })
        })
        .collect();
    Ok(Json(json!({ "layers": layers })))
}

/// Fetch `source`'s MVT for `tile`: nothing below the source's
/// `min-zoom`, the covering ancestor past its `max-zoom`, and on a miss
/// up to `overzoom_levels` parents further. The returned `CoreTileId`
/// identifies which tile the bytes actually came from — equal to `tile`
/// on a direct hit, an ancestor on overzoom. Callers that intend to
/// render must run those bytes through
/// [`ezu_features::mvt::clip_to_descendant`] when the IDs differ; callers
/// that need the raw native bytes (the `/mvt` endpoint) should treat a
/// non-matching ID as a miss.
///
/// Each level is cached independently, so two sibling tiles requesting
/// the same parent share the fetch.
async fn fetch_mvt(
    s: &AppState,
    source: &FeatureSource,
    tile: CoreTileId,
) -> Result<Option<(bytes::Bytes, CoreTileId)>, (StatusCode, String)> {
    let Some(mut current) = source.native_tile(tile) else {
        return Ok(None);
    };
    for _ in 0..=s.overzoom_levels {
        let key = (Arc::clone(&source.name), current);
        if let Some(b) = s.mvt_cache.get(&key).map(|r| r.clone()) {
            return Ok(Some((b, current)));
        }
        match source.fetch_tile(current).await {
            Ok(Some(b)) => {
                s.mvt_cache.insert(key, b.clone());
                return Ok(Some((b, current)));
            }
            Ok(None) => {}
            Err(e) => return Err((StatusCode::BAD_GATEWAY, e.to_string())),
        }
        let Some(parent) = current.parent() else {
            break;
        };
        current = parent;
    }
    Ok(None)
}

/// Pre-fetch the DEM mosaic for every source in the snapshot so the
/// blocking render path receives ready-to-bind [`ScalarField`]s
/// without juggling async fetches.
async fn fetch_dem_bindings(
    registry: &DemSourceRegistry,
    tile: TileId,
    canvas: CanvasInfo,
) -> Result<Vec<(String, ezu::graph::ScalarField)>, DemFetchError> {
    if registry.is_empty() {
        return Ok(Vec::new());
    }
    let base = BrushBankLoader::new();
    let mut tmp = TileLoader::new(&base, tile);
    bind_dem_sources(&mut tmp, registry, tile, canvas).await?;
    let mut out = Vec::new();
    for name in registry.names() {
        if let Ok(ezu::graph::Asset::ScalarField(field)) = ezu::graph::AssetLoader::load(&tmp, name)
        {
            out.push((name.to_string(), (*field).clone()));
        }
    }
    Ok(out)
}

/// Pre-fetch + stitch every raster source's mosaic for `tile`.
async fn fetch_raster_bindings(
    registry: &RasterSourceRegistry,
    tile: TileId,
    canvas: CanvasInfo,
) -> Result<Vec<(String, ezu::graph::RasterBuf)>, RasterFetchError> {
    if registry.is_empty() {
        return Ok(Vec::new());
    }
    let base = BrushBankLoader::new();
    let mut tmp = TileLoader::new(&base, tile);
    bind_raster_sources(&mut tmp, registry, tile, canvas).await?;
    let mut out = Vec::new();
    for name in registry.names() {
        if let Ok(ezu::graph::Asset::Image(buf)) = ezu::graph::AssetLoader::load(&tmp, name) {
            out.push((name.to_string(), (*buf).clone()));
        }
    }
    Ok(out)
}

/// `on-missing: error` misses surface as 404 for the rendered tile;
/// everything else is an upstream failure.
fn dem_fetch_status(e: DemFetchError) -> (StatusCode, String) {
    match &e {
        DemFetchError::Missing { .. } => (StatusCode::NOT_FOUND, e.to_string()),
        _ => (StatusCode::BAD_GATEWAY, e.to_string()),
    }
}

fn raster_fetch_status(e: RasterFetchError) -> (StatusCode, String) {
    match &e {
        RasterFetchError::Missing { .. } => (StatusCode::NOT_FOUND, e.to_string()),
        _ => (StatusCode::BAD_GATEWAY, e.to_string()),
    }
}

#[allow(clippy::too_many_arguments)]
fn render_tile(
    graph: &ezu::graph::Graph,
    cache: &ezu::graph::Cache,
    assets: &BrushBankLoader,
    fetched_mvt: Vec<FetchedMvt>,
    dem_bindings: Vec<(String, ezu::graph::ScalarField)>,
    raster_bindings: Vec<(String, ezu::graph::RasterBuf)>,
    geojson_sources: &GeoJsonSources,
    tile: CoreTileId,
    tile_size: u32,
    pad: u32,
    format: TileFormat,
    params: &ParamValues,
) -> Result<Vec<u8>, String> {
    let tile_id = TileId {
        z: tile.z,
        x: tile.x,
        y: tile.y,
    };
    let mut tile_loader = TileLoader::new(assets, tile_id);
    for (src_name, centre, neighbours) in fetched_mvt {
        if let Some((bytes, src_tile)) = centre {
            let mut decoded = mvt::decode(&bytes).map_err(|e| format!("mvt decode: {e}"))?;
            if src_tile != tile {
                tracing::debug!(
                    "overzoom clip `{src_name}` {}/{}/{} ← {}/{}/{}",
                    tile.z,
                    tile.x,
                    tile.y,
                    src_tile.z,
                    src_tile.x,
                    src_tile.y
                );
                decoded = mvt::clip_to_descendant(&decoded, src_tile, tile)
                    .map_err(|e| format!("overzoom clip: {e}"))?;
            }
            tile_loader.bind_mvt(&src_name, decoded);
        }
        for ((dx, dy), (bytes, src_tile)) in neighbours {
            let ntile = CoreTileId::new(
                tile.z,
                (tile.x as i64 + dx as i64).rem_euclid(1i64 << tile.z) as u32,
                (tile.y as i64 + dy as i64) as u32,
            );
            let mut decoded = match mvt::decode(&bytes) {
                Ok(d) => d,
                Err(e) => {
                    tracing::warn!("neighbour mvt decode {dx},{dy}: {e}");
                    continue;
                }
            };
            if src_tile != ntile {
                match mvt::clip_to_descendant(&decoded, src_tile, ntile) {
                    Ok(d) => decoded = d,
                    Err(e) => {
                        tracing::warn!("neighbour overzoom clip {dx},{dy}: {e}");
                        continue;
                    }
                }
            }
            tile_loader.bind_mvt_neighbor(&src_name, dx, dy, decoded);
        }
    }
    for (name, field) in dem_bindings {
        tile_loader.bind_scalar_field(name, field);
    }
    for (name, buf) in raster_bindings {
        tile_loader.bind_raster(name, buf);
    }
    // The documents were read when the snapshot was built; each tile only
    // re-projects them into its own frame.
    bind_geojson_sources(&mut tile_loader, geojson_sources, &graph.asset_inputs())?;
    let ev = Evaluator::new(graph, cache, &tile_loader);
    let out = ev
        .render(
            tile_id,
            CanvasInfo::square(tile_size, pad),
            params,
            tile_seed(tile),
        )
        .map_err(|e| format!("render: {e}"))?;
    let raster = match out {
        PortValue::Raster(r) => r,
        other => return Err(format!("expected Raster output, got {:?}", other.kind())),
    };
    match format {
        TileFormat::Png => raster_to_png(&raster, tile_size, pad).map_err(|e| format!("png: {e}")),
        TileFormat::Webp => {
            raster_to_webp(&raster, tile_size, pad).map_err(|e| format!("webp: {e}"))
        }
    }
}

fn tile_seed(tile: CoreTileId) -> u64 {
    let mut s = 0u64;
    s = s
        .wrapping_mul(0x9E37_79B9_7F4A_7C15)
        .wrapping_add(tile.z as u64);
    s = s
        .wrapping_mul(0x9E37_79B9_7F4A_7C15)
        .wrapping_add(tile.x as u64);
    s = s
        .wrapping_mul(0x9E37_79B9_7F4A_7C15)
        .wrapping_add(tile.y as u64);
    s
}