jelq

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

use std::time::Instant;

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

    headers::X_SEED,

    problem::{PROBLEM_BASE, 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 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;

    let mut runs = state.runs();

    runs.retain(|_, run| ctx.now.duration_since(run.last_seen) < config.idle_ttl);

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

        let mut buried: Vec<(Instant, String)> = runs

            .iter()

            .filter(|(_, run)| run.ended.is_some())

            .map(|(id, run)| (run.last_seen, id.clone()))

            .collect();

        buried.sort_unstable();

        let excess = runs.len() + 1 - config.max_runs;

        for (_, id) in buried.into_iter().take(excess) {

            runs.remove(&id);

        }

    }

    if 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 !runs.contains_key(&id) {

            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.refractory = config.refractory;

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

    runs.insert(id, 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 runs = state.runs();

    let dead: Vec<Value> = runs

        .values()

        .filter_map(|run| {

            let ending = run.ended.as_ref()?;

            Some(json!({

                "public_id": run.public_id,

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

                "detail": ending.cause.detail(),

                "turn": ending.turn,

            }))

        })

        .collect();

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

}

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

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

        None | Some("self-reported-length") => false,

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

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

            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 or content-length.",

            )

            .into_response();

        }

    };

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

    let runs = state.runs();

    let mut entries: Vec<&Run> = runs

        .values()

        .filter(|run| include_seeded || !run.seeded)

        .collect();

    let key = |run: &Run| {

        if truthful {

            run.current_length()

        } else {

            run.self_reported()

        }

    };

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

    let entries: Vec<Value> = entries

        .into_iter()

        .map(|run| {

            let mut entry = json!({

                "public_id": run.public_id,

                "status": run.status(),

                "floor": run.floor.number(),

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

                "ranked": !run.seeded,

                "viral": run.filmed_at.is_some(),

            });

            if truthful {

                entry["content_length"] = json!((run.current_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.",

    )

}