jelq

mod ctx;

mod meta;

mod middleware;

mod resource;

mod response;

mod run;

mod runs;

mod ui;

use std::{

    collections::HashMap,

    sync::{Arc, Mutex, MutexGuard, PoisonError},

};

use axum::{

    Router,

    extract::State,

    response::Redirect,

    routing::{MethodRouter, any},

};

use tower_http::catch_panic::CatchPanicLayer;

use crate::{config::Config, game::Run};

use ctx::Ctx;

use resource::Resource;

use run::RunResource;

pub struct AppState {

    runs: Mutex<HashMap<String, Run>>,

    config: Config,

}

impl AppState {

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

        Self {

            runs: Mutex::default(),

            config,

        }

    }

    /// A panic mid-request must not take every other run down with it, so a poisoned lock is recovered.

    fn runs(&self) -> MutexGuard<'_, HashMap<String, Run>> {

        self.runs.lock().unwrap_or_else(PoisonError::into_inner)

    }

    #[cfg(test)]

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

        self.runs().insert(run.id.clone(), 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(mut state): State<Shared>, ctx: Ctx| async move {

            resource.dispatch(&mut state, &ctx)

        },

    )

}

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

    any(

        move |State(state): State<Shared>, ctx: Ctx| async move { run::serve(&state, ctx, resource) },

    )

}

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)

}