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::{Value, json};

use super::{

    Shared,

    ctx::Ctx,

    resource::{Resource, Verb},

    run,

};

use crate::{

    game::{ELDER_LAST_MODIFIED, FORUM_THREAD, Run, balance::MM_PER_INCH, forum_thread, volume},

    headers::X_SEED,

    problem::{PROBLEM_BASE, Problem},

    records::Record,

};

use super::registry::hold;

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 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",

            "graveyard": "/graveyard",

            "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;

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

        state.records.save(&Record::of(&hold(&slot)));

    }

    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 id = loop {

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

        if !state.runs.contains(&id) && state.records.find(&id).is_none() {

            break id;

        }

    };

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

    let mut run = Run::with_oracle(

        id.clone(),

        public_id,

        config.secret.mix_seed(seed),

        &config.oracle,

    );

    run.seeded = seeded;

    run.last_seen = ctx.now;

    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);

    state.runs.insert(run);

    response

}

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(),

    }

}

fn graveyard(state: &mut Shared, _: &Ctx) -> Response {

    let dead: Vec<Value> = state

        .records

        .dead()

        .into_iter()

        .filter_map(|record| {

            let ending = record.ending?;

            Some(json!({

                "public_id": record.public_id,

                "cause": format!("{PROBLEM_BASE}{}", ending.cause),

                "detail": ending.detail,

                "turn": record.turn,

            }))

        })

        .collect();

    Json(json!({ "runs": dead })).into_response()

}

#[derive(Clone, Copy, PartialEq, Eq)]

enum Sort {

    SelfReported,

    ContentLength,

    /// Self-reported length against real girth, the only metric the forum respects.

    Volume,

}

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

    let sort = match ctx.query("sort") {

        None | Some("self-reported-length") => Sort::SelfReported,

        Some("volume") => Sort::Volume,

        Some("content-length") => match ctx.cookie("ruler") {

            Some(ruler) if state.config.secret.verify("ruler", ruler) == Some("1") => {

                Sort::ContentLength

            }

            Some(_) => {

                return Problem::new(

                    StatusCode::BAD_REQUEST,

                    "exaggeration",

                    "The server has measured. Lying is not a technique.",

                )

                .with("cookie", "ruler")

                .into_response();

            }

            None => {

                return Problem::new(

                    StatusCode::FORBIDDEN,

                    "ruler-required",

                    "Sorting by the truth requires a Ruler.",

                )

                .into_response();

            }

        },

        Some(_) => {

            return Problem::new(

                StatusCode::BAD_REQUEST,

                "unknown-sort",

                "The leaderboard sorts by self-reported-length, volume or content-length.",

            )

            .into_response();

        }

    };

    let include_seeded = ctx.query("seeded") == Some("include");

    let mut entries: Vec<Record> = state.runs.each(Record::of);

    entries.extend(

        state

            .records

            .all()

            .into_iter()

            .filter(|record| !state.runs.contains(&record.id)),

    );

    entries.retain(|record| include_seeded || !record.seeded);

    let key = |record: &Record| match sort {

        Sort::SelfReported => record.self_reported,

        Sort::ContentLength => record.length,

        Sort::Volume => volume(record.self_reported, record.girth),

    };

    entries.sort_by(|a, b| key(b).total_cmp(&key(a)));

    let entries: Vec<Value> = entries

        .into_iter()

        .map(|record| {

            let mut entry = json!({

                "public_id": record.public_id,

                "status": record.status,

                "floor": record.floor,

                "self_reported_length": (record.self_reported * 100.0).round() / 100.0,

                "ranked": !record.seeded,

                "viral": record.viral,

            });

            if sort == Sort::Volume {

                entry["volume"] =

                    json!((volume(record.self_reported, record.girth) * 100.0).round() / 100.0);

            }

            if sort == Sort::ContentLength {

                entry["content_length"] = json!((record.length * MM_PER_INCH).round());

            }

            entry

        })

        .collect();

    Json(json!({ "entries": entries })).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.",

    )

}