jelq

mod ctx;

mod inventory;

mod leaderboard;

mod links;

mod meta;

mod middleware;

mod parse;

mod registry;

mod resource;

mod response;

mod run;

mod runs;

mod shaft;

mod shame;

mod ui;

use std::{

    sync::Arc,

    time::{Duration, Instant},

};

use axum::{

    Router,

    extract::State,

    response::{Redirect, Response},

    routing::{MethodRouter, any},

};

use tower_http::catch_panic::CatchPanicLayer;

use crate::{

    config::Config,

    records::{Record, Records},

};

use ctx::Ctx;

use registry::{Lock, Registry};

use resource::Resource;

use run::RunResource;

pub struct AppState {

    runs: Registry,

    records: Records,

    config: Config,

}

impl AppState {

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

        let records = match &config.db {

            Some(path) => Records::open(path)?,

            None => Records::in_memory(),

        };

        Ok(Self {

            runs: Registry::default(),

            records,

            config,

        })

    }

    /// Records and forgets the runs that have gone idle. The server calls it on a timer.

    pub fn sweep(&self, now: Instant) -> rusqlite::Result<()> {

        for slot in self.runs.evict_idle(now, self.config.idle_ttl) {

            let record = match Lock::take(&slot) {

                Lock::Held(run) | Lock::Poisoned(run) => Record::of(&run),

            };

            self.records.save(&record)?;

        }

        Ok(())

    }

    #[cfg(test)]

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

        self.runs.insert_new(run);

    }

}

impl Default for AppState {

    fn default() -> Self {

        Self::new(Config::default()).expect("an in-memory database always opens")

    }

}

type Shared = Arc<AppState>;

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

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

}

/// Sweeps idle runs into the records every minute, so a quiet server still keeps its graveyard.

pub async fn sweep_forever(state: Arc<AppState>) {

    let mut ticks = tokio::time::interval(Duration::from_secs(60));

    loop {

        ticks.tick().await;

        let swept = Arc::clone(&state);

        let result = tokio::task::spawn_blocking(move || swept.sweep(Instant::now())).await;

        if let Ok(Err(error)) = result {

            eprintln!("jelqd could not sweep idle runs into the records: {error}");

        }

    }

}

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

    })

}

/// Game turns block, on SQLite always and on HTTP for every roll under the model oracle, so they

/// run on the blocking pool and leave the async workers free.

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

where

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

{

    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)

}