offline-web/exp1/src/serve.rs

use std::{collections::HashMap, sync::Arc};

use axum::{extract::Path, http, response::{Html, IntoResponse}, routing::get, Json, Router};

use offline_web_model::{Graph, Reference};

// TODO(jeremy): Allow this to autoexpand the content_addresses?
async fn all_references(root_ref: Arc<Reference>) -> Json<Arc<Reference>> {
    Json(root_ref)
}

async fn ref_path(refs: Arc<HashMap<String, Arc<Reference>>>, Path(path): Path<String>) -> Json<Arc<Reference>> {
    let path = format!("/item/{}", path);
    match refs.get(&path) {
        Some(r) => Json(r.clone()),
        None => todo!("Return a 404?"),
    }
}

async fn object_path(objects: Arc<HashMap<String, String>>, Path(addr): Path<String>) -> String {
    dbg!(&addr);
    match objects.get(&addr) {
        Some(o) => o.clone(),
        None => todo!("Return a 404?"),
    }
}

async fn get_client_js() -> impl IntoResponse {
    (
        [(http::header::CONTENT_TYPE, "application/javascript")],
        include_str!("../static/client.js"),
    )
}

pub fn endpoints(graph: Graph) -> Router {
    Router::new().nest(
        "/api/v1",
        Router::new().nest(
            "/ref",
            Router::new()
                .route("/all/username", get({
                    let state = graph.root.clone();
                    move || all_references(state)
                }))
                .route("/item/{*path}", get({
                    let refs = graph.refs.clone();
                    move |path| ref_path(refs, path)
                }))
        ).nest(
            "/object",
            Router::new()
                .route("/{addr}", get({
                        let objects = graph.objects.clone();
                        move |addr| object_path(objects, addr)
                }))
        ),
    )
    .route("/lib/client.js", get(get_client_js))
    .route("/ui/", get(|| async { Html(include_str!("../static/index.html")).into_response() }))
}

// TODO(jwall): Javascript test script
pub async fn serve() {
    // run our app with hyper, listening globally on port 3000
    let graph = Graph::random_graph();
    
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .unwrap();
    println!("Server ui starting on http://127.0.0.1:3000/ui/");
    axum::serve(listener, endpoints(graph)).await.unwrap();
}