jelq

//! Resources that do not belong to a single run.

use axum::{

    Json,

    http::{StatusCode, header},

    response::{IntoResponse, Response},

};

use rand::Rng;

use serde_json::json;

use super::{

    Shared,

    ctx::Ctx,

    leaderboard::{graveyard, leaderboard},

    resource::{Resource, Verb},

    run::{self, records_unavailable},

};

use crate::{

    game::{ELDER_LAST_MODIFIED, FORUM_THREAD, Run, forum_thread},

    headers::X_SEED,

    problem::Problem,

};

pub static INDEX: Resource<Shared> = Resource::new(&[Verb::new("GET", index)]);

pub static RUNS: Resource<Shared> = Resource::new(&[Verb::new("POST", create_run)]);

pub static THREAD: Resource<Shared> = Resource::new(&[Verb::new("GET", thread)]);

pub const GRAVEYARD_PATH: &str = "/graveyard";

pub const LEADERBOARD_PATH: &str = "/leaderboard";

pub static GRAVEYARD: Resource<Shared> = Resource::new(&[Verb::new("GET", graveyard)]);

pub static LEADERBOARD: Resource<Shared> = Resource::new(&[Verb::new("GET", leaderboard)]);

fn index(_: &mut Shared, ctx: &Ctx) -> Response {

    let wants_html = ctx

        .header(header::ACCEPT)

        .is_some_and(|accept| accept.contains("text/html"));

    if wants_html {

        return (

            StatusCode::SEE_OTHER,

            [(header::LOCATION, "/ui/"), (header::VARY, "Accept")],

        )

            .into_response();

    }

    (

        [(header::VARY, "Accept")],

        Json(json!({

            "detail": "This is jelqd. It is a roguelike. It is played over HTTP.",

            "start": { "href": "/runs", "method": "POST" },

            "leaderboard": LEADERBOARD_PATH,

            "graveyard": GRAVEYARD_PATH,

            "forum": FORUM_THREAD,

            "ui": "/ui/",

        })),

    )

        .into_response()

}

fn create_run(state: &mut Shared, ctx: &Ctx) -> Response {

    let seeded = ctx.query("seed").is_some();

    let seed = match ctx.query("seed").map(str::parse::<u64>) {

        None => rand::rng().random(),

        Some(Ok(seed)) => seed,

        Some(Err(_)) => {

            return Problem::new(

                StatusCode::BAD_REQUEST,

                "bad-seed",

                "The seed must be an unsigned 64-bit integer.",

            )

            .into_response();

        }

    };

    let config = &state.config;

    if state.runs.len() >= config.max_runs {

        return Problem::new(

            StatusCode::SERVICE_UNAVAILABLE,

            "server-full",

            "The server is full. Everyone is in there.",

        )

        .header(header::RETRY_AFTER, "600")

        .into_response();

    }

    let mut run = loop {

        let id = format!("{:032x}", rand::rng().random::<u128>());

        match state.records.find(&id) {

            Ok(None) => {}

            Ok(Some(_)) => continue,

            Err(error) => return records_unavailable(&error),

        }

        break Run::with_oracle(

            id,

            format!("{:08x}", rand::rng().random::<u32>()),

            config.secret.mix_seed(seed),

            seeded,

            &config.oracle,

        );

    };

    let response = (

        StatusCode::CREATED,

        [

            (header::LOCATION, run.path("")),

            (header::ETAG, run.etag()),

            (X_SEED, seed.to_string()),

        ],

        Json(run.view()),

    )

        .into_response();

    let response = run::finish(&mut run, ctx, &config.secret, response);

    if state.runs.insert_new(run) {

        response

    } else {

        create_run(state, ctx)

    }

}

fn thread(_: &mut Shared, ctx: &Ctx) -> Response {

    match ctx.param("year").parse::<u32>() {

        Ok(2009) => (

            [(header::LAST_MODIFIED, ELDER_LAST_MODIFIED)],

            Json(forum_thread()),

        )

            .into_response(),

        Ok(year) if year > 2009 => Problem::new(

            StatusCode::NOT_FOUND,

            "no-thread",

            "Nobody has posted since 2009.",

        )

        .with("thread", FORUM_THREAD)

        .into_response(),

        _ => Problem::new(

            StatusCode::NOT_FOUND,

            "no-thread",

            "The forum did not exist yet. The problem did.",

        )

        .with("thread", FORUM_THREAD)

        .into_response(),

    }

}

pub async fn not_found() -> Problem {

    Problem::new(

        StatusCode::NOT_FOUND,

        "not-found",

        "The resource does not exist. This is not about you.",

    )

}