jelq

mod ctx;

mod meta;

mod middleware;

mod registry;

mod resource;

mod response;

mod run;

mod runs;

mod ui;

use std::sync::Arc;

use axum::{

    Router,

    extract::State,

    response::{Redirect, Response},

    routing::{MethodRouter, any},

};

use tower_http::catch_panic::CatchPanicLayer;

use crate::{config::Config, records::Records};

use ctx::Ctx;

use registry::Registry;

use resource::Resource;

use run::RunResource;

pub struct AppState {

    runs: Registry,

    records: Records,

    config: Config,

}

impl AppState {

    pub fn new(config: Config) -> Self {

        let records = match &config.db {

            Some(path) => Records::open(path).unwrap_or_else(|e| {

                panic!("the records at {} could not be opened: {e}", path.display())

            }),

            None => Records::in_memory(),

        };

        Self {

            runs: Registry::default(),

            records,

            config,

        }

    }

    #[cfg(test)]

    pub(crate) fn insert(&self, run: crate::game::Run) {

        self.runs.insert(run);

    }

}

impl Default for AppState {

    fn default() -> Self {

        Self::new(Config::default())

    }

}

type Shared = Arc<AppState>;

pub fn app(config: Config) -> Router {

    router(Arc::new(AppState::new(config)))

}

pub fn router(state: Shared) -> Router {

    let api = api(state);

    let ui = Router::new()

        .route("/ui", any(|| async { Redirect::permanent("/ui/") }))

        .route("/ui/", any(ui::page))

        .route("/ui/send", any(ui::send))

        .with_state(api.clone());

    api.merge(ui)

        .layer(CatchPanicLayer::custom(middleware::panicked))

}

fn global(resource: &'static Resource<Shared>) -> MethodRouter<Shared> {

    any(move |State(state): State<Shared>, ctx: Ctx| async move {

        offload(state, move |mut state| resource.dispatch(&mut state, &ctx)).await

    })

}

fn scoped(resource: &'static RunResource) -> MethodRouter<Shared> {

    any(move |State(state): State<Shared>, ctx: Ctx| async move {

        offload(state, move |state| run::serve(&state, ctx, resource)).await

    })

}

/// The model oracle blocks on HTTP for every roll, so its turns run on the blocking pool and

/// leave the async workers free. Dice are quick enough to roll in place.

async fn offload<F>(state: Shared, work: F) -> Response

where

    F: FnOnce(Shared) -> Response + Send + 'static,

{

    if !state.config.oracle.blocks() {

        return work(state);

    }

    tokio::task::spawn_blocking(move || work(state))

        .await

        .unwrap_or_else(|e| std::panic::resume_unwind(e.into_panic()))

}

fn api(state: Shared) -> Router {

    Router::new()

        .route("/", global(&meta::INDEX))

        .route("/runs", global(&meta::RUNS))

        .route("/runs/{id}", scoped(&runs::RUN))

        .route("/runs/{id}/length", scoped(&runs::LENGTH))

        .route("/runs/{id}/foreskin", scoped(&runs::FORESKIN))

        .route("/runs/{id}/inventory", scoped(&runs::INVENTORY))

        .route("/runs/{id}/inventory/{item}", scoped(&runs::ITEM))

        .route("/runs/{id}/techniques", scoped(&runs::TECHNIQUES))

        .route("/runs/{id}/drawer", scoped(&runs::DRAWER))

        .route("/runs/{id}/branches/{choice}", scoped(&runs::BRANCH))

        .route("/runs/{id}/kitchen", scoped(&runs::KITCHEN))

        .route("/runs/{id}/kitchen/watermelon", scoped(&runs::MELON))

        .route("/runs/{id}/re-read", scoped(&runs::REREAD))

        .route("/runs/{id}/floor", scoped(&runs::FLOOR))

        .route("/runs/{id}/shop", scoped(&runs::SHOP))

        .route("/runs/{id}/shop/{item}", scoped(&runs::BUY))

        .route("/runs/{id}/portal", scoped(&runs::PORTAL))

        .route("/runs/{id}/elder", scoped(&runs::ELDER))

        .route("/runs/{id}/grip", scoped(&runs::GRIP))

        .route("/runs/{id}/diagnosis", scoped(&runs::DIAGNOSIS))

        .route("/runs/{id}/footage", scoped(&runs::FOOTAGE))

        .route("/forum/threads/{year}", global(&meta::THREAD))

        .route("/graveyard", global(&meta::GRAVEYARD))

        .route("/leaderboard", global(&meta::LEADERBOARD))

        .fallback(meta::not_found)

        .layer(axum::middleware::from_fn(middleware::chrome))

        .layer(CatchPanicLayer::custom(middleware::panicked))

        .with_state(state)

}