jelq

//! The public listings, paged fifty at a time with RFC 8288 `next` and `prev` links.

use axum::{

    Json,

    http::{StatusCode, header},

    response::{IntoResponse, Response},

};

use serde_json::{Value, json};

use super::{Shared, ctx::Ctx, run::records_unavailable};

use crate::{

    game::{balance::MM_PER_INCH, volume},

    problem::{PROBLEM_BASE, Problem},

    records::{Ranking, Record},

};

const PAGE: usize = 50;

fn page(ctx: &Ctx) -> Result<usize, Problem> {

    match ctx.query("page").map(str::parse::<usize>) {

        None => Ok(1),

        Some(Ok(page)) if page >= 1 => Ok(page),

        Some(_) => Err(Problem::new(

            StatusCode::BAD_REQUEST,

            "bad-page",

            "Pages are counted from 1.",

        )),

    }

}

/// `query` is everything but the page, already encoded, so the links keep the caller's sort.

fn paged(body: Value, path: &str, query: &str, page: usize, full: bool) -> Response {

    let link = |page: usize, rel: &str| {

        let separator = if query.is_empty() { "" } else { "&" };

        format!("<{path}?{query}{separator}page={page}>; rel=\"{rel}\"")

    };

    let mut links = Vec::new();

    if page > 1 {

        links.push(link(page - 1, "prev"));

    }

    if full {

        links.push(link(page + 1, "next"));

    }

    let mut response = Json(body).into_response();

    if links.is_empty() {

        return response;

    }

    if let Ok(value) = links.join(", ").parse() {

        response.headers_mut().insert(header::LINK, value);

    }

    response

}

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

    let page = match page(ctx) {

        Ok(page) => page,

        Err(problem) => return problem.into_response(),

    };

    let dead = match state.records.dead((page - 1) * PAGE, PAGE) {

        Ok(dead) => dead,

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

    };

    let full = dead.len() == PAGE;

    let runs: Vec<Value> = dead

        .into_iter()

        .filter_map(|record| {

            let cause = record.cause?;

            Some(json!({

                "public_id": record.public_id,

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

                "detail": cause.detail(),

                "turn": record.turn,

            }))

        })

        .collect();

    paged(json!({ "runs": runs }), "/graveyard", "", page, full)

}

fn ranking(state: &Shared, ctx: &Ctx) -> Result<Ranking, Problem> {

    match ctx.query("sort") {

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

        Some("volume") => Ok(Ranking::Volume),

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

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

                Ok(Ranking::ContentLength)

            }

            Some(_) => Err(Problem::new(

                StatusCode::BAD_REQUEST,

                "exaggeration",

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

            )

            .with("cookie", "ruler")),

            None => Err(Problem::new(

                StatusCode::FORBIDDEN,

                "ruler-required",

                "Sorting by the truth requires a Ruler.",

            )),

        },

        Some(_) => Err(Problem::new(

            StatusCode::BAD_REQUEST,

            "unknown-sort",

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

        )),

    }

}

fn score(ranking: Ranking, record: &Record) -> f64 {

    match ranking {

        Ranking::SelfReported => record.self_reported,

        Ranking::ContentLength => record.length,

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

    }

}

fn entry(ranking: Ranking, record: &Record) -> Value {

    let mut entry = json!({

        "public_id": record.public_id,

        "status": record.status.name(),

        "floor": record.floor,

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

        "ranked": !record.seeded,

        "viral": record.viral,

    });

    match ranking {

        Ranking::Volume => {

            entry["volume"] = json!((score(ranking, record) * 100.0).round() / 100.0);

        }

        Ranking::ContentLength => {

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

        }

        Ranking::SelfReported => {}

    }

    entry

}

/// Live runs are ranked alongside the recorded ones, and a live run outranks its own stale record.

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

    let (ranking, page) = match ranking(state, ctx).and_then(|r| Ok((r, page(ctx)?))) {

        Ok(parsed) => parsed,

        Err(problem) => return problem.into_response(),

    };

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

    let mut entries: Vec<Record> = state

        .runs

        .each(Record::of)

        .into_iter()

        .filter(|record| seeded || !record.seeded)

        .collect();

    let wanted = page * PAGE;

    match state

        .records

        .top(ranking, seeded, 0, wanted + entries.len())

    {

        Ok(recorded) => entries.extend(

            recorded

                .into_iter()

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

        ),

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

    }

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

    let full = entries.len() > wanted;

    let listed: Vec<Value> = entries

        .iter()

        .skip(wanted - PAGE)

        .take(PAGE)

        .map(|record| entry(ranking, record))

        .collect();

    let mut query = Vec::new();

    if let Some(sort) = ctx.query("sort") {

        query.push(format!("sort={sort}"));

    }

    if seeded {

        query.push("seeded=include".to_owned());

    }

    paged(

        json!({ "entries": listed }),

        "/leaderboard",

        &query.join("&"),

        page,

        full,

    )

}