smokesignal / src / http / handle_geo_aggregation.rs

use axum::Json;
use axum::extract::{Query, State};
use axum::http::StatusCode;
use axum::response::IntoResponse;
use serde::{Deserialize, Serialize};

use std::collections::HashMap;

use crate::http::context::WebContext;
use crate::http::errors::WebError;
use crate::search_index::{GeoCenter, GeoHexBucket, SearchIndexManager};

/// H3 precision level (5 = ~8.5km edge length)
const PRECISION: u8 = 7;
/// Search radius in miles
const DISTANCE_MILES: f64 = 60.0;

#[derive(Debug, Deserialize)]
pub(crate) struct GeoAggregationParams {
    /// Center latitude
    lat: f64,
    /// Center longitude
    lon: f64,
}

#[derive(Debug, Serialize)]
pub(crate) struct GeoAggregationResponse {
    pub buckets: Vec<GeoHexBucket>,
}

/// GET /api/geo-aggregation
///
/// Returns H3 hexagonal grid aggregation of upcoming event locations
/// within 300 miles of the specified center point.
///
/// Query parameters:
/// - lat: Center latitude (required)
/// - lon: Center longitude (required)
pub(crate) async fn handle_geo_aggregation(
    State(web_context): State<WebContext>,
    Query(params): Query<GeoAggregationParams>,
) -> Result<impl IntoResponse, WebError> {
    let opensearch_endpoint = match web_context.config.opensearch_endpoint.as_ref() {
        Some(value) => value,
        None => {
            return Ok((
                StatusCode::SERVICE_UNAVAILABLE,
                Json(GeoAggregationResponse { buckets: vec![] }),
            )
                .into_response());
        }
    };

    let manager = match SearchIndexManager::new(opensearch_endpoint) {
        Ok(m) => m,
        Err(err) => {
            tracing::error!(?err, "Failed to create search index manager");
            return Ok((
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(GeoAggregationResponse { buckets: vec![] }),
            )
                .into_response());
        }
    };

    let center = GeoCenter {
        lat: params.lat,
        lon: params.lon,
        distance_miles: DISTANCE_MILES,
    };

    let buckets = manager
        .get_event_geo_aggregation(PRECISION, Some(center), true)
        .await
        .unwrap_or_default();

    Ok((StatusCode::OK, Json(GeoAggregationResponse { buckets })).into_response())
}

/// Default H3 precision for globe view (lower for world-scale)
const GLOBE_PRECISION: u8 = 3;

#[derive(Debug, Deserialize)]
pub(crate) struct GlobeAggregationParams {
    /// H3 resolution (1-7, default 3 for world view)
    #[serde(default = "default_resolution")]
    resolution: u8,
}

fn default_resolution() -> u8 {
    GLOBE_PRECISION
}

#[derive(Debug, Serialize)]
pub(crate) struct GlobeHexBucket {
    /// H3 cell index
    pub key: String,
    /// Number of events in this cell
    pub event_count: u64,
    /// Number of LFG profiles in this cell
    pub lfg_count: u64,
    /// Total activity (events + profiles)
    pub total: u64,
}

#[derive(Debug, Serialize)]
pub(crate) struct GlobeAggregationResponse {
    pub buckets: Vec<GlobeHexBucket>,
}

/// GET /api/globe-aggregation
///
/// Returns H3 hexagonal grid aggregation of events and LFG profiles globally.
/// Used for the 3D globe visualization on the homepage.
///
/// Query parameters:
/// - resolution: H3 resolution level (1-7, default 3)
pub(crate) async fn handle_globe_aggregation(
    State(web_context): State<WebContext>,
    Query(params): Query<GlobeAggregationParams>,
) -> Result<impl IntoResponse, WebError> {
    let opensearch_endpoint = match web_context.config.opensearch_endpoint.as_ref() {
        Some(value) => value,
        None => {
            return Ok((
                StatusCode::SERVICE_UNAVAILABLE,
                Json(GlobeAggregationResponse { buckets: vec![] }),
            )
                .into_response());
        }
    };

    let manager = match SearchIndexManager::new(opensearch_endpoint) {
        Ok(m) => m,
        Err(err) => {
            tracing::error!(?err, "Failed to create search index manager");
            return Ok((
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(GlobeAggregationResponse { buckets: vec![] }),
            )
                .into_response());
        }
    };

    // Clamp resolution to valid range (1-7)
    let resolution = params.resolution.clamp(1, 7);

    // Fetch both event and LFG aggregations in parallel
    let (event_result, lfg_result) = tokio::join!(
        manager.get_event_geo_aggregation(resolution, None, true),
        manager.get_lfg_profile_geo_aggregation(resolution, None),
    );

    let event_buckets = event_result.unwrap_or_default();
    let lfg_buckets = lfg_result.unwrap_or_default();

    // Merge buckets by H3 key
    let mut merged: HashMap<String, GlobeHexBucket> = HashMap::new();

    for bucket in event_buckets {
        merged
            .entry(bucket.key.clone())
            .and_modify(|b| {
                b.event_count += bucket.doc_count;
                b.total += bucket.doc_count;
            })
            .or_insert(GlobeHexBucket {
                key: bucket.key,
                event_count: bucket.doc_count,
                lfg_count: 0,
                total: bucket.doc_count,
            });
    }

    for bucket in lfg_buckets {
        merged
            .entry(bucket.key.clone())
            .and_modify(|b| {
                b.lfg_count += bucket.doc_count;
                b.total += bucket.doc_count;
            })
            .or_insert(GlobeHexBucket {
                key: bucket.key,
                event_count: 0,
                lfg_count: bucket.doc_count,
                total: bucket.doc_count,
            });
    }

    let buckets: Vec<GlobeHexBucket> = merged.into_values().collect();

    Ok((StatusCode::OK, Json(GlobeAggregationResponse { buckets })).into_response())
}